Internet Engineering Task Force                                 F. Baker
Diffserv Working Group                                     Cisco Systems
INTERNET-DRAFT                                                   K. Chan
          Expires:September
Expires November 2000                                     Nortel Networks
draft-ietf-diffserv-mib-03.txt                                  A. Smith
                                                        Extreme Networks
                  Management Information Base for the
                  Differentiated Services Architecture

                          draft-ietf-diffserv-mib-02.txt

          Abstract

          This memo describes a proposed MIB for the Differentiated
          Services Architecture [Architecture] and described by the
          Differentiated Services Router Conceptual Model [Model].

          Currently total agreement on content of this MIB has not been
          reached, especially in the dropping and queueing mechanism
          attributes.  Further discussion on these topics are required
          for finalizing this memo.

          1.

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.

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
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 particular draft document is being developed in a product of the IETF's Differentiated Services Working
Group. Discussion of it therefore belongs on
          that list. 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

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

          3.

2.  Structure of this MIB

This MIB is designed according to the Differentiated Services
implementation conceptual model documented in [Model].

          3.1. [MODEL].

2.1.  Overview

          In principle, if one were to construct a network entirely out

The conceptual model [MODEL] discusses the way we model the ingress and
egress interfaces of two-port routers (in appropriate places connected by LANs
          or similar media), an 'n'-port router. In this MIB, we model these
identically, making the distinction between them an index variable.
Each interface then it would be necessary for each router
          to perform exactly four QoS control functions on traffic in
          each direction:

          - performs some or all of the following high-level
functions:

o    Classify each message packet according to some set of rules

          -    In edge devices, determine

o    Determine whether the data stream the
               message packet is part of is within
     or outside its rate

          -

o    Perform some a set of resulting actions, minimally possibly including applying a counting the
     traffic, application of an appropriate drop policy appropriate to the
               classification and queue in question, and in edge devices
               perhaps additionally marking of
     the traffic with a Differentiated Services Code Point (DSCP) as
     defined in
               [DSCP].

          - [DSFIELD].

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

          If we build

The MIB therefore contains the network out following elements:

Classifier and Filter Tables
     A general extensible framework and one example (an IP Six-Tuple
     Multi-Field Classification Table).

Meter Tables
     A general extensible framework and one example (an exponential
     weighted moving average meter).

Action Tables
     Absolute Drop, Mark and Count actions. The "multiplexer",
     "replicator" and "null" actions described in [MODEL] are
     accomplished implicitly by means of N-port routers, we expect the
          behavior RowPointer structures of
     the network to be identical. We are forced,
          therefore, to provide essentially the same set of functions on
          the ingress port of a router as on the egress port of a
          router. Some interfaces will be "edge" interfaces and some
          will be "interior" to the Differentiated Services domain. The
          one point of difference between an ingress and an egress
          interface is that all traffic on an egress interface is
          queued, while traffic on an ingress interface will typically
          be queued only for shaping purposes.

          Hence, in this MIB, we model them identically, making the
          distinction between ingress and egress interfaces an index
          variable.

          The MIB therefore contains the following elements:
          - IP Six Tuple Multi-Field Classification Table
          - Classifier Table
          - Meter Table
          - Action other elements.

Queue, Scheduler and Action Type Algorithmic Dropper Tables
          - Queue Set,
     Queue, Scheduler and Queue Measurement Tables

          3.2.  Classifier Table Algorithmic Dropper Tables.

2.2.  Classifiers

The classifier table indicates and filter tables determine how traffic is sorted out. It
          identifies
They identify separable classes of traffic, by reference to an
appropriate classifier, filter, which may be select anything from an individual micro-flow micro-
flow to aggregates identified by DSCP.  It
          then sends

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

2.2.1.  Classifier Table

The structure of the classifier table table, as described in [MODEL], is a
sequence of unambiguous tests. Within each step stage in the sequence, it should
must not be important in which order - if order is present at all - the tests are made. This is to
facilitate optimized implementations such as index trees. Sequence Order is
present in
          order only to resolve ambiguity.

          For example, one might want first to disallow certain
          applications from using ambiguity: for that reason the network at all, or stage in the
sequence is referred to classify
          some individual traffic streams that here and in [MODEL] as the "precedence" of the
classifier stage: stages with higher values of precedence are not diff-serv marked.
          Traffic that fails those compared
first; the order of tests might then be inspected for a
          DSCP. "Then" implies sequence, and entries of the sequence must be
          somehow specified. same precedence is
unimportant.

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

The definition of the actual filter to be used by the classifier definition is
referenced via a
          RowPointer, RowPointer: this enable enables the use of any sort of classification filter
table that one might wish to design, public standard or proprietary.
          That classifier The filter
table need may be, but does not be found need to be, defined in this MIB.  When
          ambiguity is present, we disambiguate by explicitly ordering
          the application of classification rules. MIB module.

The classifiers specified here are at the per interface level, level i.e. they are
indexed by ifIndex: they may be derived from some higher level policies, more general policies
e.g. something based on interface roles, but such discussion is out- side outside
the scope of this document.

          3.2.1. See e.g. [POLTERM] section 4 for a
discussion of Roles.

2.2.2.  IP Six Tuple Six-Tuple Classifier Table

This MIB currently specifies the includes a definition for an IP Six Tuple Six-Tuple Classifier, used for
IP traffic classification.  Entry of Entries in this Classifier Table
          is filter table are referenced

from the entries of the diffServClassifierTable
          via a RowPointer, namely RowPointer diffServClassifierPattern attribute attributes of diffServClassifierEntry object.

          The classifier
table entries.

A Behavior Aggregate (BA) Classifier Classifier, acting only on DSCPs, is a simple
form of the IP Six Tuple Six-Tuple Classifier. It is represented by having the
diffServSixTupleClfrDscp attribute set to the desired DSCP, DSCP and all other
classification attributes set to match-all, the their default setting. settings. The
alternative approach of providing a specific definition in this MIB for
a BA Classifier was discussed and rejected.

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

          3.3.  Meter Table [MODEL].

2.3.  Meters

A meter, according to the conceptual model, [MODEL] section 5, measures the rate at which
packets making up a stream of traffic passes pass it, compares it this rate to
some set of thresholds, thresholds and produces some number (two or more) of
potential results. A given message packet is said to "conform" to the meter if if,
at the time that the message packet is being looked at at, the stream appears to be
within the meter's limit rate. In the
          MIB, the structure of SNMP profile. MIB syntax makes it easiest to implement define this
as a set sequence of one or more simple cascaded pass/fail tests, which are
          cascaded. modeled here as
if-then-else constructs.

It is important to be understood understand that this way of modelling does not imply
anything about the meter in 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 stages: the stages are introduced merely as a Traffic
          Control Block notational
convenience in order to simplify the MIB structure.

2.3.1.  Meter Table

The generic meter table is therefore implemented used as a set base for all more specific forms of if-then-
          else constructs.
meter.  The concept definition of conformance the specific parameters of the meter to be
used is referenced via a RowPointer: this enables the use of any sort of
specific meter bears a comment. table that one might wish to design, standard or
proprietary. The
          concept applied specific meter table may be, but does not need to be,
defined in several rate-control architectures,
          including ATM, Frame Relay, Integrated Services, and
          Differentiated Services, this MIB module.

2.3.2.  Token-Bucket Meter Table

This is variously described included as a "leaky
          bucket" or a "token bucket".

          A leaky bucket algorithm is primarily used for traffic
          shaping: traffic theoretically departs from the switch at a
          flat rate an example of one bit every so many time units, and in fact
          departs in packets at a rate approximating that. It is also
          possible to build multi-rate leaky buckets, common type of meter.  Entries in which traffic
          departs
this table are referenced from the switch at varying rates depending on recent
          activity or inactivity.

          A token bucket is used to measure the behavior RowPointer diffServMeterSpecific

attributes of a peer's
          leaky bucket, for verification purposes. It is, meter table entries.  The parameters are represented by definition, a relationship

                            interval = burst/rate, or
rate = burst/interval

          for some defined burst size, in bits, rate, in bits per
          second, and time interval. Multi-rate token buckets (token
          buckets with both a peak diffServTBMeterRate and a mean rate, and sometimes more
          rates) are commonly used. In this case, the burst size for diffServTBMeterBurstSize.

2.4.  Actions

Actions include "no action", "mark the
          baseline traffic is conventionally referred to as the
          "committed burst", and with a DSCP", "drop the time interval is
traffic" or "count it". Other tasks such as specified by

                       interval = committed burst/mean rate

          but additional burst sizes (each an increment over its
          predecessor) are defined, which "shape the traffic" or "drop
based on some algorithm" are conventionally referred to handled elsewhere as "excess" burst sizes. queueing mechanisms,
rather than actions, consistent with [MODEL].  The peak rate therefore equals the
          sum "multiplexer",
"replicator" and "null" actions described in [MODEL] are accomplished
implicitly by means of the burst sizes per interval.

          A data stream is said to "conform" to a simple token bucket if
          the switch receives at most RowPointer structures of the burst size in a given time
          interval. In other elements.

This MIB uses the multi-rate case, Action Table diffServActionTable to organize one
Action's relationship with the traffic is said element(s) before and after it. It allows
Actions to
          conform be cascaded to enable multiple Actions be applied to the token bucket at a given level if its rate does
          not exceed the sum of single
traffic stream by using each entry's diffServActionNext attribute.  The
last entry's diffServActionNext attribute may point to the relevant burst sizes in next TCB
element, normally a given
          interval. Received traffic pre-classified at one of Queueing element.

The parameters needed for each Action element will depend on the
          "excess" rates (e.g., AF12 or AF13 traffic) is only compared type of
Action to be taken. Hence there are specific Action Tables for all the relevant excess buckets.

          The fact that data is organized into variable length packets
          introduces some uncertainty
different Action types.  This flexibility allows additional Actions be
specified in this. For future revisions of this reason, MIB, or in other MIBs and also
allows for the
          token bucket accepts a packet if any use of its bits would have
          been accepted, and "borrows" any excess capacity required from
          that allotted proprietary Actions without impact on those
defined here.

2.4.1.  DSCP Mark Action Table

This Action is applied to equivalently classified traffic in order to mark it with a previous
          or subsequent interval. More information about this is
          available Diffserv
Codepoint (DSCP) value, specified in [Model].

          Multiple classes of traffic, as identified by the classifier
          table, may diffServDscpMarkActTable.
Other marking actions might be presented specified elsewhere - these are outside
the scope of this MIB.

2.4.2.  Count Action Table

Count Actions are used to count the same meter. Imagine, for traffic passing along a particular
path through the model. If specified, they are likely to be placed
first, before other types of Action. For example, that we desire when both a Count and
an Absolute Dropper Action are specified, the Count Action needs to drop all
count the traffic that uses stream before any DSCP traffic gets dropped.  Note that has not been publicly defined.  A classifier entry might
          exist for each such DSCP, shunting it
there are counters contained directly in Algorithmic Dropper elements to an "accepts
          everything" meter,
indicate the amount of traffic dropped by those elements.

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

2.4.3.  Absolute Drop Action

This action just silently discards all traffic that conforms to
          only that meter.

          Clearly, it is necessary to identify what is presented to be done with
          messages that conform to the meter, it, without
counting it. This action has no additional parameters and with messages that do
          not. It so is also necessary for the meter to be arbitrarily
          extensible,
represented only as some PHBs require the successive application of
          an arbitrary number a diffServActionType of meters.  The approach taken dropAlways without any
specific parameters (diffServActionSpecific value will be null).

2.5.  Queueing Elements

These include Algorithmic Droppers, Queues and Schedulers.

2.5.1.  Algorithmic Dropper Table

Algorithmic Droppers have a close relationship with queueing: they are
represented in this
          design is MIB by entries in an Algorithmic Dropper Table.
Entries contain a "next" attribute which indicates to have each meter indicate what action is which queue they
sink their traffic. They may also contain a pointer to be
          taken specific detail
of the drop algorithm. This MIB only defines the detail for conforming traffic, and what meter one drop
algorithm, Tail Drop; other algorithms are outside the scope of this MIB
but the general framework is intended to be used allow for
          traffic which fails to conform. With the definition their inclusion in
other modules.

One generally-applicable parameter of a
          special type dropper is the specification of meter to
a queue-depth threshold at which all traffic conforms, we now
          have the necessary flexibility.

          3.4.  Action Table

          Considerable discussion has taken place regarding the possible
          actions.  Suggested actions include "no action", "mark the
          traffic", "drop the traffic, based on some algorithm", "shape
          the traffic", "count it".  This MIB attempts drop action is to make the
          specification start. This is
represented in this MIB, as a base attribute of the action flexible Algorithmic Dropper
entry, by using the Action Table pointing to organize one Action's relationship with the Meter element
          before it, with the Queueing element following it, and with
          other Action elements queue for which depth is to allow multiple Actions be applied compared and
the threshold, in bytes, to compare against.

<ed: is we need to represent a single traffic stream.  The parameters needed will depend dropper as depending on
          the type of Action to be taken.  Hence there are Action Tables
          for the different Action Types.  This MIB currently defines
          parameters for:  1. Mark Action, 2. Count Action, 3. Drop
          Action,

          This flexibility allows additional Actions be specified in
          future revisions of multiple queues
then this MIB, or in other MIBs.  And possible
          usage of propietary Action without impact to the Actions
          provided here.

          The Mark Action is relatively straight forward.

          For Count Action, when it is specified, it will always be
          applied first, before any other type of Actions.  For example,
          when both Count single-queue pointer and a Drop Action threshold is specified, the Count
          Action not adequate: should we
leave them here or not? they will always count the total counts of this traffic
          stream, before any traffic gets dropped, even if the Action
          entries are chained with the Drop Action first, before the
          Count Action.  There are counters in the Drop Actions to
          indicate the ammount of traffic dropped, within the drop
          context.

          The Drop Actions require close relationship with queueing,
          with detail as follows:

          The be useful for many, but not all,
dropper algorithms.>

o    A Tail Drop Action Dropper requires the specification of a maximum queue depth, depth
     threshold: when the queue pointed at which point by diffServAlgDropQMeasure
     reaches that depth threshold, diffServAlgDropQThresh, any new
     traffic exceeding arriving at the maximum
          queue depth gets discarded.

          *Editor's Note Start*
          There dropper is still debates on what
          attributes are needed and how they may be related to queueing.
          The following is viewed as the complex description discarded.

o    Random Droppers require more detailed specification of how it
          may be done.  The following set the
     characteristics of attributes and its
          description may be simplified before this memo is finalized.
          There is a more detail discussion their drop functions. Representations of why these attributes
     functions are
          required in [ActQMgmt].
          *Editor's Note End*

          The Random Drop Action requires outside the specification scope of its drop
          characteristic with this MIB although they should
     use the following available diffServAlgDropQMeasure and
     diffServAlgDropQThresh parameters (drop
          characteristic described using a where possible.

<ed: should we keep this example (next 3 paragraphs) or not? It is not
supported by the current MIB.>
     As an example of a random dropper, RED-like droppers often have the
     function described as a plot with of drop probability,
          P, as Y axis, and average probability (P) against
     averaged queue length, Q, as X axis):
          1. Pmin and Qmin length (Q).  (Qmin,Pmin) defines the start of the
     characteristic plot.  Normally Pmin=0, meaning with average queue
     length below Qmin, there will be no drops.
          2. Pmax and Qmax  (Qmax,Pmax) defines a
     "knee" on the plot, after which point the drop probability become
     more progressive (greater slope).
             Qclip  (Qclip,1) defines the average queue
     length at which all packets will be dropped, probability = 1. dropped. Notice this is
     different from Tail Drop because this uses average an averaged queue
     length.  It is possible for Qclip = Qmax, meaning when Qmax.

     The calculation of the average averaged queue length exceeds Qmax, all packets will be dropped.
          3. The sampling interval and average weight parameters are used
             for calculation may also have an
     important bearing on the behaviour of average queue.  These the dropper: parameters are
             important because they can affect may
     include the behavior sampling interval and outcome
             of the drop process.  They can also weight of each sample. The
     performance may be very sensitive to the values of these parameters
     and
             may have a wide range of possible values may be required due to a wide
     range of link speeds, hence the use of real number format for
             average weight. speeds. There is ongoing research on this topic, see
     e.g. [ACTQMGMT].

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

          For the drop actions, each drop process

Each 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 implementation implementations may require.  This
          setup also
allows the flexibility for Action specification,
          including sequences of multiple sequential drop processes droppers if necessary.

          When counters are specified, two sizes of objects are defined.
          These are defined

2.5.2.  Queues and Schedulers

The Queue Table models simple FIFO queues, as described in accordance with the method found [MODEL]
section 7.1.1.  The Scheduler Table allows flexibility in
          [IFMIB]; constructing
both 32 simple and 64 bit counters are defined, with the
          expectation somewhat more complex 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 32 bit counter is simply the least
          significant bits Queue Table have attributes which include a
specification of the 64 bit counter. For interfaces that
          operate scheduler which services the queue. They are
pointed at 20,000,000 (20 million) bits per second or less,
          32-bit byte and packet counters MUST be used.  For interfaces by the "next" attributes of the upstream elements e.g.
diffServMeterSucceedNext.  Note that operate faster than 20,000,000 bits/second, and slower
          than 650,000,000 bits/second, 32-bit packet counters MUST be
          used and 64-bit octet counters MUST be used. multiple upstream elements may
direct their traffic to the same Queue Table entry. For interfaces example, the
Assured Forwarding PHB suggests that operate at 650,000,000 bits/second all traffic marked AF11, AF12 or faster, 64-bit
          packet counters AND 64-bit octet counters MUST
AF13 be used.

          Multiple Actions can placed in the same queue, after metering, without reordering.
This would be chained using represented by having the ActionNext
          attribute.  The last Action's ActionNext attribute points to diffServMeterSucceedNext of each

upstream meter point at the next TCB, normally a Queue Entry for same entry in the Queue element.

          3.5.  Queueing Element

          The Queueing element consists of Queue Table and Queue Set Table.  With Queue

The Scheduler Table containing relatively simple FIFO
          queues.  Using represented in this MIB module contains entries,
each of which represents the Queue Set Table to allow flexibility algorithm in
          constructing both simple and complex queueing hierarchies. use for servicing the one or
more queues that feed it. The queue entries [MODEL] section 7.1.2 describes a
scheduler with multiple inputs: this is represented in the MIB by
including the scheduling parameters associated with a scheduler input in
the Queue Table have simple attributes, entry that feeds it includes a reference and having that point at one
particular Scheduler Table entry. In this way, sets of Queues can be
grouped together as inputs to which queue set the queue belongs
          to, and a weight parameter.  For Priority Queueing, same Scheduler.  This table serves to
represent the weight
          parameter indicates example scheduler described in the priority [MODEL]: other more
complex representations might be created outside of this queue MIB.

Each scheduler input, as represented by a Queue Table entry, is assigned
a priority with respect to all the other queues within inputs feeding the same queue set.
scheduler.  A higher
          weight value queue higher-priority input will be service serviced first over a lower weight
          value queue in lower-
priority input, assuming that all guarantees have already been met.
This priority parameter, used on its own with default values for the same queue set.
other parameters, serves to allow representation of a Strict Priority
scheduler.

For weighed queueing
          algorithms, Weighted Queueing algorithms e.g. WFQ, WRR, the weight parameter "weight" of a given
scheduler input is represented with a percentage number.  With
          the value of 1,000 meaning 1 percent, allowing fine control of Minimum Service Rate leaky-bucket
profile which provides guaranteed bandwidth allocation when needed.  A higher weight value queue
          will have higher probability of being service when compared to that input, if required.
This is represented, as were token-bucket meters, by a lower weight value queue in the same queue set. rate
diffServQueueMinRateAbs and a burst size diffServQueueMinBurstSize. The weight
          values for all the queues within
rate may, alternatively, be represented by a queue set must add up to
          less than or equal to 100,000 (100%).  Each queue is capable
          of acting relative value, as a work-conserving queue, one which transmits as
          rapidly as its weight allows, but guarantees to its class
fraction of
          traffic, as the interface's current line rate, diffServQueueMinRateRel
to assist in cases where line rates are variable or where a side effect higher-level
policy might be expressed in terms of fractions of network resources.
The two rate parameters are inter-related and changes in one may be
reflected in the other.

An input may also be capable of its weight, a minimum rate.  Or acting as a non-work-conserving "shaping" queue.

          The entries [MODEL]
traffic shaper: this is done by defining a Maximum Service Rate leaky-
bucket profile in the Queue Set Table describes the attributes
          common order to all queues within limit the queue set. scheduler bandwidth available to
that input.  This includes the
          dequeueing Method, or algorithm used amongst the queues in the
          queue set.  Currently, priority queueing, Weighed Fair
          Queueing, Weighed Round Robin are listed as is represented, similarly to the possible
          chooses, other methods/algorithms, e.g. Class Base Queueing,
          can be added.

          The rates, both minimum rate, by a
rate diffServQueueMaxRateAbs and maximum, are specified for a burst size diffServQueueMaxBurstSize.
The rate may, alternatively, be represented by a relative value, as a
fraction of the
          queue set instead of per queue.  This allows

          A hierarchical tree interface's current line rate, diffServQueueMaxRateRel.

2.5.3.  Example of queue sets can be constructed using the
          parent/child queue set concept.  The attributes QSetParentId
          and QSetWeight is used for this purpose, with QSetParentId
          indicating the parent's QSetId, Algorithmic Droppers, Queues and QSetWeight used as the
          child queue set's total weight amongst the queues in the
          parent queue set.  There can be multiple children queue set
          under one parent queue set, with each child queue set looks
          like a queue from the parent queue set's perspective.  Hence
          queue sets can be recursively defined, inter mixing with
          queues at any level.

          A mixed dequeue scheduling discipline can be built for Schedulers

As an
          interface.  For example, with the following queues and queue
          sets:

            Q Parameters          Q Set Parameters hypothetical queue/scheduler configuration shown in
[MODEL] section 8.1 is shown in Table 1.

  QId QSetId QWeight    Method MinRate ParentId QSetWeight           MaxRate           Priority   Scheduler
  --- ------ -------    ------ ------- ----------------  ----------------  -------- ----------
             11     61     100        PQ       0        0          0
             12     61      99        PQ       0        0          0

             21     71  50,000       WFQ   10000       61         98
             22     71  30,000       WFQ   10000       61         98
             23     71  20,000       WFQ   10000       61         98

             31     81  70,000       WRR     500       61         97
             32     81  30,000       WRR     500       61         97

          Notice in this example there are three queue sets:  Queue Set
          61 uses Priority Queueing, it have   ---------
  1   100kbps/20kbyte   none/none           20       Scheduler.1
  2 child Queue Sets.  Queue
          Set 71 uses Weighed Fair Queueing with KBPS as RateUnit.   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 Set 81 uses Weighed Round Robin with Packets/Sec as
          RateUnit. and Scheduler Parameters

Queues 11, 12, queue sets 71 1 and 81 belongs 3 are serviced for long enough to give them their promised
bandwidths and burst sizes, if they need them.  Queue Set 61.
          Queues 21, 22, 23 belongs 2 is then serviced
up to its maximum limit profile.  Only then does Queue Set 71.  Queues 31, 32
          belongs 4 get an
opportunity to Queue Set 81.

          All traffic in queue 11 will send its traffic.  As an example of the use of the MIB
structures, Figure 1 shows how the example would be serviced first, then all
          traffic in queue 12 will represented.

2.5.4.  Example of extending this MIB

     <ed: is it worth having this example here?>

One way to extend this MIB structure to accomodate a more complex
dropping algorithm might be serviced second.  After traffic in
          queues 11 and 12 are serviced, queues 21, 22, 23 are serviced
          among themselves in to define a fair queueing fashion, based on their
          respective weight.  After traffic specific dropper table in queues 21, 22, 23 are
          serviced, queues 31, 32 are serviced among themselves in a
          round robin fashion, based on their respective weight.  Notice
          Queue Set 71 uses KBPS RateUnit, resulting in bit/byte fair
          queueing.  Queue Set 81 uses Packet RateUnit, resulting
another MIB module, pointed at by diffServAlgDropSpecific, containing
its own parameters, as shown in
          packet fair queueing.

          The rates figure 2. This algorithm might depend
for each queue can be derived:  Queue 21 have
          minimum rate of 50% of 10000 KBPS, 5000 KBPS.  Queue 31 have
          minimum rate of 70% of 500 Pkt/Sec, 350 Pkt/Sec.

          Other types its operation e.g. on feedback of scheduling algorithms can be used in the parent
          or child queue sets, creating different queueing behaviors.

          The queue set can also operate as a traffic shaper queue's depth but pre-processed
by using some type of smoothing function with its own parameters. The extended
table could still use some of the maximum rate attribute.

          Chains fields of Queues/Queue Sets can be built using the NextTCB
          attribute in Queue Set entry.

          Multiple meters may direct their traffic standard Algorithmic
Dropper Table, if relevant, although any divergent uses would have to the same queue.
          For example, the Assured Forwarding PHB suggests that all
          traffic marked AF11, AF12, or AF13 be placed
well-documented in the same queue
          without reordering.

          3.6. extended MIB.

2.6.  The use of RowPointer

RowPointer is a textual convention used to identify a conceptual row in
an SNMP Table by pointing to one of its objects. In this MIB, it is used
in two ways: to indicate
          indirection, indirection and to indicate succession.

When used for indirection, as in the Classifier table, diffServClassifierTable, the idea
is to allow other MIBs, including proprietary ones, to identify new and
arcane classifiers - MAC headers, IP4 and IP6 headers, BGP Communities, Communities
and all sorts of other things.

When used for succession, it answers the question "what happens next?".
Rather than presume that the next table must be as specified in the conceptual model and providing its
          index,
                          +-----------+
  ----------------------->| 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|  or next TCB
                                         |    +----------+
      +-----------+       +-----------+  |   Scheduler.ifIndex.1
  --->| Next    -----+--->| Next    -----+
      | Thresh=2k |  |    | Min=Profl3|  |
      | Measure -----+    | Max=none  |  |
      | Type=Tail |       | Pri=20    |  |
      | Spec=none |       | Type=fifo |  |
      +-----------+       +-----------+  |
        Dropper.2        Queue.ifIndex.3 |
                                         |
      +-----------+       +-----------+  |
  --->| Next   ------+--->| Next    -----+
      | Thresh=4k |  |    | Min=none  |
      | Measure -----+    | Max=none  |
      | Type=Tail |       | Pri=10    |
      | Spec=none |       | Type=fifo |
      +-----------+       +-----------+
        Dropper.3        Queue.ifIndex.4

      Figure 1: Example of the RowPointer takes you use of Queueing elements
      +-----------+       +-----------+
  --->| Next   ------+--->| Next    ---------> to the MIB row representing
          that thing. In the Meter Table, Scheduler
      | Thresh=X  |  |    | Min=none  |
      | Measure -----+    | Max=none  |
      | Type=Ext  |       | Pri=10    |
      | Spec    -----+    | Type=fifo |
      +-----------+  |    +-----------+
        Dropper.3    |   Queue.ifIndex.4
                     |
                     |    +-------------+
                     +--->|Smooth1=10   |
                          |Smooth2=2000 |
                          | <etc.>      |
                          +-------------+
                           DropperExt.3

  Figure 2: Example of extending the MIB for more complex droppers

conceptual model [MODEL] and providing its index, the RowPointer takes
you to the MIB row representing that thing. In the diffServMeterTable,
for example, the "FailNext" diffServMeterFailNext RowPointer might take you to
another meter, while the
          "SucceedNext" diffServMeterSucceedNext RowPointer would take
you to an action.

          4.  MIB Definition

          DIFF-SERV-MIB DEFINITIONS ::= BEGIN

              IMPORTS
              Unsigned32, Counter32, Counter64, OBJECT-TYPE,
              MODULE-IDENTITY, zeroDotZero, mib-2          FROM SNMPv2-SMI
              TEXTUAL-CONVENTION, RowStatus, RowPointer, TestAndIncr
                                                           FROM SNMPv2-TC
              MODULE-COMPLIANCE, OBJECT-GROUP              FROM SNMPv2-CONF
              ifIndex                                      FROM IF-MIB
              DisplayString                                FROM RFC1213-MIB
              InetAddressType, InetAddress                 FROM INET-ADDRESS-MIB;

          diffServMib MODULE-IDENTITY
              LAST-UPDATED "9907190100Z" -- Mon Jul 19 01:00:00 PDT 1999
              ORGANIZATION "Cisco Systems"
              CONTACT-INFO
                 "       Fred Baker
                 Postal: 519 Lado Drive
                         Santa Barbara, California 93111
                 Tel: +1 (408) 526-4257
                 FAX: +1 (805) 681-0115
                 E-mail: fred@cisco.com

                         Kwok Ho Chan
                 Postal: 600 Technology Park Drive
                         Billerica, Massachusetts 01821, USA
                 Tel: +1 (978) 288-8175
                 FAX: +1 (978) 288-4690
                 E-mail: khchan@nortelnetworks.com

                         Andrew Smith
                 Postal: 3585 Monroe St.
                         Santa Clara, California 95051
                 Tel: +1 (408) 579 2821
                 FAX: +1 (408) 579 3000
                 E-mail: andrew@extremenetworks.com"
              DESCRIPTION
                 "This

The RowPointer construct is used to build the TCBs described in [MODEL]:
this MIB defines does not model TCBs directly - it operates at a lower level of
abstraction using only individual elements, connected in succession by
RowPointers. Therefore, the objects necessary concept of TCBs enclosed in other more
functional TCBs is not applicable to manage this MIB, although such a
                 device concept
may be employed by management tools that uses the Differentiated Services
                 Architecture described use this MIB.

3.  Editorial information

<this section will be removed before publication>

3.1.  Open Issues resolved in RFC 2475 and the Conceptual
                 Model for DiffServ Routers this draft

(0)  Terminology is more in draft-ietf-diffserv-
                 model-01.txt."
              REVISION "9907190100Z" -- Mon Jul 19 01:00:00 PDT 1999
              DESCRIPTION
                 "Initial version, published as RFC xxxx."
              ::= { mib-2 12345 }  -- anybody who uses 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 unassigned
                                   -- number deserves by allowing a multi-rate TB in the wrath of IANA

          diffServObjects        OBJECT IDENTIFIER ::= { diffServMib 1 }
          diffServTables         OBJECT IDENTIFIER ::= { diffServMib 2 }
          diffServAugments       OBJECT IDENTIFIER ::= { diffServMib 3 }
          diffServMIBConformance OBJECT IDENTIFIER ::= { diffServMib 4 }

          --
          -- These textual conventions has no effect on either the syntax
          -- nor the semantics of any managed object.  Objects defined
          -- using this convention are always encoded
     MIB? Or, by means of defining cascaded buckets to mean "multi-rate". (assume
     the
          -- rules that define 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 primitive type.
          --
          Dscp ::= TEXTUAL-CONVENTION
              DISPLAY-HINT "d"
              STATUS   current
              DESCRIPTION
                 "The code point used for discriminating own or is a traffic
                 stream."
              SYNTAX   INTEGER (-1 | 0..63)

          SixTupleClfrL4Port ::= TEXTUAL-CONVENTION
              DISPLAY-HINT "d"
              STATUS   current
              DESCRIPTION
                 "A value indicating "counter
     action", as described in the Model, sufficient to count all paths
     through a Layer-4 protocol port number."
              SYNTAX   INTEGER (0..65535)
          --
          -- Classifiers
          --
          -- 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 tools 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 IP Six Tuple Classification.

          -- 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 object allows a configuring system to obtain a
          -- unique value for diffServSixTupleClfrId RIO - multiple averaging functions for purposes
          -- of configuration.

          diffServSixTupleClfrUnique OBJECT-TYPE
              SYNTAX       TestAndIncr
              MAX-ACCESS   read-write
              STATUS       current
              DESCRIPTION
                 "The diffServSixTupleClfrUnique object yields a unique new
                 value 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 diffServSixTupleClfrId when read "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 subsequently
                 set. This value 64-bit counters - conformance
     statements sort out which ones must be tested for uniqueness."
              ::= { diffServObjects 1 }

          diffServSixTupleClfrTable OBJECT-TYPE
              SYNTAX       SEQUENCE OF DiffServSixTupleClfrEntry
              MAX-ACCESS   not-accessible
              STATUS       current
              DESCRIPTION
                 "A implemented. This is
     consistent with [IFMIB]. DONE.

(13) Droppers: we used to have a common "dropper" table of IP Six Tuple Classifier entries that a
                 system may use represented
     all of: dropAlways, randomDrop, tailDrop with just some parameters
     valid for the simpler ones. A simpler representation is to identify traffic."
              ::= { diffServTables 1 }

          diffServSixTupleClfrEntry OBJECT-TYPE
              SYNTAX       DiffServSixTupleClfrEntry
              MAX-ACCESS   not-accessible
              STATUS       current
              DESCRIPTION
                 "An IP Six Tuple Classifier entry describes define
     specific dropper tables for each type (e.g. a single
                 classifier."
              INDEX { diffServSixTupleClfrId }
              ::= { diffServSixTupleClfrTable 1 }

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

          diffServSixTupleClfrId OBJECT-TYPE
              SYNTAX         Unsigned32 (1..2147483647)
              MAX-ACCESS     not-accessible
              STATUS         current
              DESCRIPTION
                 "A unique id OID to point
     at for dropAlways since it is always the classifier. This object last action in a chain)
     but this would mean a larger number of (simpler) MIB objects.
     CHANGES: dropAlways is meant
                 to be pointed still an Action but the others are moved to by
     a RowPointer from other tables,
                 such as the diffServClassifierPattern."
              ::= { diffServSixTupleClfrEntry 1 }

          diffServSixTupleClfrAddrType OBJECT-TYPE
              SYNTAX         InetAddressType
              MAX-ACCESS     read-write
              STATUS         current
              DESCRIPTION
                 "The type diffServAlgDropTable. This table can handle tail/head drop. Other
     algorithms, specifically RED, are out of IP address used scope for now but can be
     added using the framework defined here.

(14) Should TBMeterTable just AUGMENT the MeterTable, should it use same
     indices or are separate structures linked by this classifier entry."
              ::= { diffServSixTupleClfrEntry 2 }

          diffServSixTupleClfrDstAddr OBJECT-TYPE
              SYNTAX         InetAddress
              MAX-ACCESS     read-write
              STATUS         current
              DESCRIPTION
                 "The IP address RowPointers
     preferable? SAME INDICES - DONE.

(15) Do we need to match against model multiple queues feeding back into a single
     dropper algorithm? (yes).  If so, the packet's
                 destination IP address."
              ::= { diffServSixTupleClfrEntry 3 }

          diffServSixTupleClfrDstAddrMask OBJECT-TYPE
              SYNTAX         InetAddress
              MAX-ACCESS     read-write
              STATUS current
              DESCRIPTION
                 "A mask single-queue pointer
     and threshold will not be adequate - should we leave them in? They
     will be useful for the matching 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 destination IP address.
                 A zero bit in same
     direction (allowed by the mask means that model) then we do not have a way to
     indicate "this is the corresponding bit
                 in 1st one". Moreover, it is a somewhat
     convoluted process to then find the address always matches."
              DEFVAL         {0}
              ::= { diffServSixTupleClfrEntry 4 }

          diffServSixTupleClfrSrcAddr OBJECT-TYPE
              SYNTAX         InetAddress
              MAX-ACCESS     read-write
              STATUS         current
              DESCRIPTION
                 "The IP address 2nd, 3rd etc. ones - you would
     have to match against follow the source IP address
                 of 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 packet."
              ::= { diffServSixTupleClfrEntry 5 }

          diffServSixTupleClfrSrcAddrMask OBJECT-TYPE
              SYNTAX         InetAddress
              MAX-ACCESS     read-write
              STATUS         current
              DESCRIPTION
                 "A mask filter entry
     of a classifier (yes) - added another index to classifiers to
     represent what "level" they operate at for a given
     interface/direction.

3.2.  Still Open Issues

(16) How should the matching creation of counter actions be under the source IP address.  A
                 zero bit in the mask means that the corresponding bit
                 in the address always matches."
              DEFVAL         {0}
              ::= { diffServSixTupleClfrEntry 6 }

          diffServSixTupleClfrDscp OBJECT-TYPE
              SYNTAX         Dscp
              MAX-ACCESS     read-write
              STATUS         current
              DESCRIPTION
                 "The value that control of
     manager or agent: should a diffServActionEntry and
     diffServCountActEntry appear by magic (the device surely knows what
     counters it can and cannot maintain on a given interface)? (assume
     no) If not, should diffServCountActEntry appear magically when a
     diffServAction element is created which points at the DSCP
     diffServCountActTable (then would be no need for
     diffServCountActStatus)? (assume no)

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

(19) Should manager be allowed to
                 match this entry. A value create Scheduler elements or should
     agent be in control of -1 indicates that this? (the former)

(20) Related to (17) above, do we also need a
                 specific DSCP value has not been defined "level" index for elements
     other than classifiers? (no)

(21) Do we need diffServAlgDropType of both "headDrop" and thus all
                 DSCP values are considered a match."
              DEFVAL         {-1}
              ::= { diffServSixTupleClfrEntry 7 }

          diffServSixTupleClfrProtocol OBJECT-TYPE
              SYNTAX         INTEGER (0..255)
              MAX-ACCESS     read-write
              STATUS         current
              DESCRIPTION
                 "The IP protocol to match against "tailDrop" or
     should we just represent the IPv4 protocol
                 number in tail dropper by placing a dropper
     after the packet. A value queue instead of zero means match all."
              DEFVAL         {0}
              ::= { diffServSixTupleClfrEntry 8 }

          diffServSixTupleClfrDstL4PortMin OBJECT-TYPE
              SYNTAX         SixTupleClfrL4Port
              MAX-ACCESS     read-create
              STATUS         current
              DESCRIPTION
                 "The minimum value that before the layer-4 destination port
                 number in queue, as linked by the packet must have in order
     diffServQNext and diffServAlgDropNext RowPointers? (the former).

(22) Do we need to match this
                 classifier entry."
              DEFVAL         {0} support RED algorithms for algorithm parameter
     configuration and monitoring?  If so, what variables are needed?

4.  MIB Definition

DIFF-SERV-MIB DEFINITIONS ::= { diffServSixTupleClfrEntry 9 }

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

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

          diffServSixTupleClfrSrcL4PortMax OBJECT-TYPE
              SYNTAX         SixTupleClfrL4Port
              MAX-ACCESS     read-write
              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 the value specified for this entry in
                 dsSixTupleIpSrcL4PortMin."
              DEFVAL         {65535}
              ::= { diffServSixTupleClfrEntry 12 }

          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 be modified whether the row is active or
                 notInService."
              ::= { diffServSixTupleClfrEntry 13 }

          -- Classifier Table
          -- This object allows a configuring system to obtain a
          -- unique value for diffServClassifierNumber for purposes of
          -- configuration

          diffServClassifierUnique OBJECT-TYPE
              SYNTAX       TestAndIncr
              MAX-ACCESS   read-write
              STATUS       current
              DESCRIPTION
                 "The diffServClassifierUnique object yields a unique
                 new value for diffServClassifierId when read and
                 subsequently set. This value must be tested for
                 uniqueness."
              ::= { diffServObjects 2 }

          -- The Classifier Table allows us to enumerate the relationship
          -- between arbitrary classifiers and the meters which apply
          -- to classified streams.

          diffServClassifierTable OBJECT-TYPE
              SYNTAX       SEQUENCE OF DiffServClassifierEntry
              MAX-ACCESS   not-accessible
              STATUS       current
              DESCRIPTION
                 "The classifier table defines the classifiers that a
                 system applies to incoming traffic.  Specific
                 classifiers are defined by RowPointers in this table
                 which identify entries in classifier tables of specific
                 type, e.g.  Multi-field classifiers for IP are defined
                 in diffServSixTupleClfrTable.  Other classifier types
                 may be defined elsewhere."
              ::= { diffServTables 2 }

          diffServClassifierEntry OBJECT-TYPE
              SYNTAX       DiffServClassifierEntry
              MAX-ACCESS   not-accessible
              STATUS       current
              DESCRIPTION
                 "An entry in the classifier table describes a single
                 classifier."
              INDEX { ifIndex, diffServInterfaceDirection,
                      diffServClassifierId }
              ::= { diffServClassifierTable 1 }

          DiffServClassifierEntry ::= SEQUENCE  {
              diffServInterfaceDirection     INTEGER,
              diffServClassifierId BEGIN

    IMPORTS
    Unsigned32,
              diffServClassifierPattern      RowPointer,
              diffServClassifierNext Counter32, Counter64, OBJECT-TYPE,
    MODULE-IDENTITY, OBJECT-IDENTITY, zeroDotZero, mib-2
         FROM SNMPv2-SMI
    TEXTUAL-CONVENTION, RowStatus, RowPointer,
              diffServClassifierPrecedence   Unsigned32,
              diffServClassifierStatus       RowStatus
          }

          diffServInterfaceDirection OBJECT-TYPE
              SYNTAX  INTEGER {
                          inbound(1),     -- ingress interface
                          outbound(2)     -- egress interface
                      }
              MAX-ACCESS   not-accessible
              STATUS       current
              DESCRIPTION
                 "Specifies the direction for this entry on the
                 interface. 'inbound' traffic is operated on during
                 receipt, while 'outbound' traffic is operated on prior
                 to transmission."
              ::= { diffServClassifierEntry 1 }

          diffServClassifierId OBJECT-TYPE
              SYNTAX       Unsigned32 (1..2147483647)
              MAX-ACCESS   not-accessible
              STATUS       current
              DESCRIPTION
                 "Classifier Id enumerates the classifier entry."
              ::= { diffServClassifierEntry 2 }

          diffServClassifierPattern OBJECT-TYPE
              SYNTAX       RowPointer
              MAX-ACCESS   read-create
              STATUS       current TestAndIncr
         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 "200005110000Z"
    ORGANIZATION "IETF Diffserv WG"
    CONTACT-INFO
       "       Brian Carpenter (co-chair of Diffserv WG)
               c/o iCAIR
               1890 Maple Ave, #150
               Evanston, IL 60201, USA
       Phone:  +1 847 467 7811
       E-mail: brian@icair.org

               Kathie Nichols (co-chair of Diffserv WG)
               Cisco Systems
               170 W. Tasman Drive
               San Jose, CA 95134-1706, USA
       Phone:  +1 408 525 4857
       E-mail: kmn@cisco.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)
               Extreme Networks
               3585 Monroe St.
               Santa Clara, CA 95051, USA
       E-mail: andrew@extremenetworks.com"
    DESCRIPTION
                 "A pointer
       "This MIB defines the objects necessary to manage a valid entry in another table device that
                 describes
       uses the applicable classification pattern, e.g.
                 an entry Differentiated Services Architecture described in diffServSixTupleClfrTable.  If the row
                 pointed to does not exist, RFC
       2475 and the classifier is ignored.

                 The value zeroDotZero is interpreted to match anything
                 not matched by another classifier - only one such entry
                 may exist Conceptual Model for DiffServ Routers in draft-ietf-
       diffserv-model-03.txt."
    REVISION "200005110000Z"
    DESCRIPTION
       "Initial version, published as RFC xxxx."
    ::= { mib-2 12345 }  -- anybody who uses this table."
              DEFVAL unassigned
                         -- number deserves the wrath of IANA

diffServObjects        OBJECT IDENTIFIER ::= { zeroDotZero diffServMib 1 }
diffServTables         OBJECT IDENTIFIER ::= { diffServClassifierEntry diffServMib 2 }
diffServMIBConformance OBJECT IDENTIFIER ::= { diffServMib 3 }

          diffServClassifierNext OBJECT-TYPE
              SYNTAX       RowPointer
              MAX-ACCESS   read-create
              STATUS       current
              DESCRIPTION
                 "The 'next' variable selects

-- These textual conventions have no effect on either the next datapath element
                 to handle syntax
-- nor the classified flow.  For example, semantics of any managed object.  Objects defined
-- using this can
                 points to an entry in convention are always encoded by means of the meter or action table."
-- rules that define their primitive type.

Dscp ::= { diffServClassifierEntry 4 }

          diffServClassifierPrecedence OBJECT-TYPE
              SYNTAX       Unsigned32
              MAX-ACCESS   read-create TEXTUAL-CONVENTION
    DISPLAY-HINT "d"
    STATUS   current
    DESCRIPTION
       "The relative precedence in which classifiers are
                 applied, higer numbers represent classifiers with
                 higher precedence.  Classifiers with the same
                 precedence must be unambiguous, i.e. they must define
                 non-overlapping patterns.  Classifiers with different
                 precedence may overlap in their patterns:  the
                 classifier with the highest precedence IP header Diffserv Code-Point that matches may be used for
       discriminating or marking a traffic stream.  The value -1 is
                 taken."
              DEFVAL { 0 } used
       to indicate a wildcard i.e. any value."
    SYNTAX   INTEGER (-1 | 0..63)

SixTupleClfrL4Port ::= { diffServClassifierEntry 5 }

          diffServClassifierStatus OBJECT-TYPE TEXTUAL-CONVENTION
    DISPLAY-HINT "d"
    STATUS   current
    DESCRIPTION
       "A value indicating a Layer-4 protocol port number."
    SYNTAX       RowStatus
              MAX-ACCESS   read-create   INTEGER (0..65535)

IfDirection ::= TEXTUAL-CONVENTION
    STATUS current
    DESCRIPTION
                 "The RowStatus variable controls the activation,
                 deactivation, or deletion of
       "Specifies a classifier. Any writable
                 variable may be modified whether direction of data travel on an interface. 'inbound'
       traffic is operated on during reception from the row interface, while
       'outbound' traffic is active or
                 notInService."
              ::= operated on prior to transmission on the
       interface."
    SYNTAX  INTEGER { diffServClassifierEntry 6
                inbound(1),     -- ingress interface
                outbound(2)     -- egress interface
            }

--
-- Meters Classifiers
--

-- This MIB includes definitions for Token-Bucket
-- Meters as one example of possible meters. Classifier Table
-- This object

-- The Classifier Table allows a configuring system us to obtain a
          -- unique value for diffServTBMeterId for purposes of enumerate the relationship
-- configuration

          diffServTBMeterUnique OBJECT-TYPE
              SYNTAX       TestAndIncr
              MAX-ACCESS   read-write
              STATUS       current
              DESCRIPTION
                 "The diffServTBMeterUnique object yields a unique new
                 value for diffServTBMeterId when read between arbitrary classifiers and subsequently
                 set. This value must be tested for uniqueness."
              ::= { diffServObjects 3 }

          diffServTBMeterTable the subsequent downstream
-- Diffserv elements.

diffServClassifierTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServTBMeterEntry DiffServClassifierEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Meter Table enumerates specific token bucket
                 meters classifier table defines the classifiers that a system may use
       applies to police a stream of
                 classified incoming traffic. The traffic stream is  Specific classifiers are defined by
       RowPointers in the classifier.  It entries of this table which identify entries
       in filter tables of specific types, e.g.  Multi-Field Classifiers
       (MFCs) for IP are defined in the diffServSixTupleClfrTable. Other
       classifier types may include all traffic." be defined elsewhere."
    REFERENCE
        "[MODEL] section 4.1"
    ::= { diffServTables 3 1 }

          diffServTBMeterEntry

diffServClassifierEntry OBJECT-TYPE
    SYNTAX       DiffServTBMeterEntry       DiffServClassifierEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the meter classifier table describes a single token
                 bucket meter. Note that a meter has exactly one rate,
                 defined as the burst size each time interval. Multiple
                 meters may be cascaded should a multi-rate token bucket
                 be needed in a given Per-Hop Behavior. An example element of
                 such a PHB is AF."
       the classifier."
    INDEX { ifIndex, diffServInterfaceDirection,
                      diffServTBMeterId diffServClassifierIfDirection,
            diffServClassifierLevel, diffServClassifierId }
    ::= { diffServTBMeterTable diffServClassifierTable 1 }
          DiffServTBMeterEntry

DiffServClassifierEntry ::= SEQUENCE  {
              diffServTBMeterId                Unsigned32,
              diffServTBMeterRate              Unsigned32,
              diffServTBMeterBurstSize
    diffServClassifierIfDirection  IfDirection,
    diffServClassifierLevel        Unsigned32,
              diffServTBMeterFailNext
    diffServClassifierId           INTEGER,
    diffServClassifierFilter       RowPointer,
              diffServTBMeterSucceedNext
    diffServClassifierNext         RowPointer,
              diffServTBMeterStatus
    diffServClassifierPrecedence   Unsigned32,
    diffServClassifierStatus       RowStatus
}

          diffServTBMeterId

diffServClassifierIfDirection OBJECT-TYPE
    SYNTAX       Unsigned32 (1..2147483647)  IfDirection
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
                 "MeterId enumerates
       "Specifies the meter entry." direction for this classifier entry on the
       interface."
    ::= { diffServTBMeterEntry diffServClassifierEntry 1 }

          diffServTBMeterRate

diffServClassifierLevel OBJECT-TYPE
    SYNTAX       Unsigned32
              UNITS        "KBPS"
    MAX-ACCESS   read-create   not-accessible
    STATUS       current
    DESCRIPTION
                 "The token bucket rate, in kilo-bits per second (KBPS).
                 Note that if multiple meters are cascaded onto one PHB,
       "Specifies the peak rate level of the data stream TCB of which this classifier element
       is the sum a part. Lower numbers indicate an element that belongs to a
       classifier that is part of their
                 rates." a TCB that is applied to traffic
       before those with higher numbers."
    ::= { diffServTBMeterEntry diffServClassifierEntry 2 }

          diffServTBMeterBurstSize

diffServClassifierId OBJECT-TYPE
    SYNTAX       Unsigned32
              UNITS        "bytes"       INTEGER (0..2147483647)
    MAX-ACCESS   read-create   not-accessible
    STATUS       current
    DESCRIPTION
                 "The number
       "A classifier ID that enumerates the classifier elements. The set
       of bytes such identifiers spans the whole agent - managers should
       obtain new values for row creation in a single transmission burst.
                 The interval can be derived with (BurstSizex8)/Rate." this table by using
       diffServClassifierUnique."
    ::= { diffServTBMeterEntry diffServClassifierEntry 3 }

          diffServTBMeterFailNext

diffServClassifierFilter OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
                 "If the traffic does NOT conform
       "A pointer to a valid entry in another table that describes the meter, FailNext
                 indicates
       applicable classification filter, e.g. an entry in
       diffServSixTupleClfrTable.  If the next datapath element row pointed to handle does not exist,
       the
                 traffic.  For example, an Action or Meter datapath
                 element. classifier is ignored.

       The value zeroDotZero in this variable
                 indicates no further DiffServ treatment is performed on
                 this flow interpreted to match anything not
       matched by the current interface for another classifier - only one such entry may exist in
       this interface
                 direction." table."
    DEFVAL { zeroDotZero }
    ::= { diffServTBMeterEntry diffServClassifierEntry 4 }

          diffServTBMeterSucceedNext

diffServClassifierNext OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
                 "If the traffic does conform to the meter, SucceedNext
                 indicates
       "This selects the next datapath element to handle packets
       matching the
                 traffic. filter pattern. For example, this can point to an Action or Meter datapath
                 element.  The value zeroDotZero
       entry in this variable
                 indicates no further DiffServ treatment is performed on
                 this flow by the current interface for this interface
                 direction."
              DEFVAL      { zeroDotZero } a meter or action table."
    ::= { diffServTBMeterEntry diffServClassifierEntry 5 }

          diffServTBMeterStatus

diffServClassifierPrecedence OBJECT-TYPE
    SYNTAX       RowStatus       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The RowStatus variable controls the activation,
                 deactivation, or deletion of a meter. Any writable
                 variable may be modified whether the row is active or
                 notInService."
              ::= { diffServTBMeterEntry 6 }
          --
          -- Actions
          --
          -- Notice the Drop Action attributes relative precedence in which classifiers are referenced by the
          -- action table rather than by the queue table because
          -- Differentiated Services PHBs, such as applied: higher
       numbers represent classifiers with higher precedence.
       Classifiers with the Assured Service,
          -- permit differently classified traffic to have different
          -- drop parameters even though same precedence must be unambiguous i.e.
       they occupy must define non-overlapping patterns.  Classifiers with
       different precedence may overlap in their filters: the same queue."
          --

          -- Mark Action Table
          -- Rows of this table classifier
       with the highest precedence that matches is pointed to by diffServAction to
          -- provide detail parameters specific to an Action Type.

          -- This object allows taken.

       On a configuring system to obtain given interface, there must be a
          -- unique value for diffServMarkActId for purposes complete classifier in
       place at all times. This means that there must be always be one
       or more filters that match every possible pattern that could be
       presented in an inclming packet."
    DEFVAL { 0 }
    ::= { diffServClassifierEntry 6 }

diffServClassifierStatus OBJECT-TYPE
    SYNTAX       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The RowStatus variable controls the activation, deactivation, or
       deletion of
          -- configuration.

          diffServMarkActUnique a classifier. Any writable variable may be modified
       whether the row is active or notInService."
    ::= { diffServClassifierEntry 7 }

diffServClassifierUnique OBJECT-TYPE
    SYNTAX       TestAndIncr
    MAX-ACCESS   read-write
    STATUS       current
    DESCRIPTION
       "The diffServMarkActUnique diffServClassifierUnique object yields a unique new value
       for diffServMarkActId diffServClassifierId when read and subsequently set. This
       value must be tested for uniqueness." uniqueness and can be used by a
       configuring system to obtain a unique value for
       diffServClassifierId for purposes of row creation in the
       diffServClassifierTable."
    ::= { diffServObjects 4 1 }

          diffServMarkActTable

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

diffServSixTupleClfrTable OBJECT-TYPE
    SYNTAX      SEQUENCE OF DiffServMarkActEntry DiffServSixTupleClfrEntry
    MAX-ACCESS   not-accessible
    STATUS      current
    DESCRIPTION
                 "The mark action table enumerates specific DSCPs used
                 for marking or remarking the DSCP field.  The entries
                 of this
       "A table is meant to be referenced by the
                 diffServAction attribute of IP Six-Tuple Classifier filter entries in
                 diffServActionTable for diffServActionType = mark." that a system
       may use to identify IP traffic."
    REFERENCE
        "[MODEL] section 4.2.2"
    ::= { diffServTables 4 2 }

          diffServMarkActEntry

diffServSixTupleClfrEntry OBJECT-TYPE
    SYNTAX       DiffServMarkActEntry       DiffServSixTupleClfrEntry
    MAX-ACCESS   not-accessible
    STATUS      current
    DESCRIPTION
       "An IP Six-Tuple Classifier entry in the mark action table describes a single
                 DSCP used for marking." filter."
    INDEX { diffServMarkActId diffServSixTupleClfrId }
    ::= { diffServMarkActTable diffServSixTupleClfrTable 1 }

          DiffServMarkActEntry

DiffServSixTupleClfrEntry ::= SEQUENCE {
              diffServMarkActId
    diffServSixTupleClfrId           INTEGER,
    diffServSixTupleClfrDstAddrType  InetAddressType,
    diffServSixTupleClfrDstAddr      InetAddress,
    diffServSixTupleClfrDstAddrMask  Unsigned32,
              diffServMarkActDscp          Dscp,
              diffServMarkActStatus        RowStatus
          }

          diffServMarkActId OBJECT-TYPE
              SYNTAX       Unsigned32 (1..2147483647)
              MAX-ACCESS   not-accessible
              STATUS       current
              DESCRIPTION
                 "Mark Action Id enumerates the Mark Action entry."
              ::= { diffServMarkActEntry 1 }

          diffServMarkActDSCP OBJECT-TYPE
              SYNTAX       Dscp
              MAX-ACCESS   read-create
              STATUS       current
              DESCRIPTION
                 "The DSCP this Action TCB uses for marking/remarking
                 traffic with."  Note that if the classifier is working
                 from the same DSCP value, no effective change in the
                 DSCP results.

                 Differentiated Services may result in packet remarking
                 both on ingress to a network and on egress, and it is
                 quite possible that ingress and egress would occur in
                 the same router."
              ::= { diffServMarkActEntry 2
    diffServSixTupleClfrSrcAddrType  InetAddressType,
    diffServSixTupleClfrSrcAddr      InetAddress,
    diffServSixTupleClfrSrcAddrMask  Unsigned32,
    diffServSixTupleClfrDscp         Dscp,
    diffServSixTupleClfrProtocol     INTEGER,
    diffServSixTupleClfrDstL4PortMin SixTupleClfrL4Port,
    diffServSixTupleClfrDstL4PortMax SixTupleClfrL4Port,
    diffServSixTupleClfrSrcL4PortMin SixTupleClfrL4Port,
    diffServSixTupleClfrSrcL4PortMax SixTupleClfrL4Port,
    diffServSixTupleClfrStatus       RowStatus

}

          diffServMarkActStatus

diffServSixTupleClfrId OBJECT-TYPE
    SYNTAX       RowStatus         INTEGER (0..2147483647)
    MAX-ACCESS   read-create     not-accessible
    STATUS        current
    DESCRIPTION
                 "The RowStatus variable controls
       "A unique id for the activation,
                 deactivation, or deletion of this entry. Any writable
                 variable filter. Filters may be modified whether shared by multiple
       interfaces in the row is active or
                 notInService." same system."
    ::= { diffServMarkActEntry 3 diffServSixTupleClfrEntry 1 }

          -- Count Action Table
          -- Rows of this table is pointed to by diffServAction to
          -- provide detail parameters specific to Count Action.

          -- This object allows a configuring system to obtain a
          -- unique value for diffServCountActId for purposes of
          -- configuration.

          diffServCountActUnique

diffServSixTupleClfrDstAddrType OBJECT-TYPE
    SYNTAX       TestAndIncr         InetAddressType
    MAX-ACCESS   read-write     read-create
    STATUS         current
    DESCRIPTION
       "The diffServCountActUnique object yields a unique new
                 value for diffServCountActId when read and subsequently
                 set. This value must be tested for uniqueness." type of IP destination address used by this classifier
       entry."
    ::= { diffServObjects 5 diffServSixTupleClfrEntry 2 }

          diffServCountActTable

diffServSixTupleClfrDstAddr OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServCountActEntry         InetAddress
    MAX-ACCESS   not-accessible     read-create
    STATUS         current
    DESCRIPTION
       "The count action table contains flow specific
                 counters.  The entries of this table is meant IP address to be
                 referenced by match against the diffServAction attribute of entries
                 in diffServActionTable for diffServActionType = count." packet's destination IP
       address."
    ::= { diffServTables 5 diffServSixTupleClfrEntry 3 }

          diffServCountActEntry

diffServSixTupleClfrDstAddrMask OBJECT-TYPE
    SYNTAX       DiffServCountActEntry         Unsigned32
    MAX-ACCESS   not-accessible     read-create
    STATUS         current
    DESCRIPTION
                 "An entry
       "The length of a mask for the matching of the destination IP
       address.  Masks are constructed by setting bits in sequence from
       the count action table describes a single
                 set most-significant bit downwards for
       diffServSixTupleClfrDstAddrMask bits length. All other bits in
       the mask, up to the number needed to fill the length of flow specific counters.  This counter entry is
                 associated with a traffic flow via the
                 diffServActionEntry pointing to it."
              INDEX { diffServActionId, diffServCountActId }
       address diffServSixTupleClfrDstAddr are cleared to zero.  A zero
       bit in the mask then means that the corresponding bit in the
       address always matches."
    DEFVAL         {0}
    ::= { diffServCountActTable 1 diffServSixTupleClfrEntry 4 }

          DiffServCountActEntry

diffServSixTupleClfrSrcAddrType OBJECT-TYPE
    SYNTAX         InetAddressType
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The type of IP source address used by this classifier entry."
    ::= SEQUENCE {
              diffServCountActId           Unsigned32,
              diffServCountActOctetsCnt    Counter32,
              diffServCountActPktsCnt      Counter32,
              diffServCountActStatus       RowStatus diffServSixTupleClfrEntry 5 }

          diffServCountActId

diffServSixTupleClfrSrcAddr OBJECT-TYPE
    SYNTAX       Unsigned32 (1..2147483647)         InetAddress
    MAX-ACCESS   not-accessible     read-create
    STATUS         current
    DESCRIPTION
                 "Count Action Id enumerates
       "The IP address to match against the Count Action entry." source IP address of each
       packet."
    ::= { diffServCountActEntry 1 diffServSixTupleClfrEntry 6 }

          diffServCountActOctetsCnt

diffServSixTupleClfrSrcAddrMask OBJECT-TYPE
    SYNTAX       Counter32
              UNITS        "octets"         Unsigned32
    MAX-ACCESS   read-only     read-create
    STATUS         current
    DESCRIPTION
       "The number length of Octets at a mask for the Action datapath element.
                 Meaning matching of the octets has been classified and possibly
                 metered, and prior to any dropping process. This object
                 may be used on low speed interfaces, and represents source IP address.
       Masks are constructed by setting bits in sequence from the
                 least most-
       significant 32 bit downwards for diffServSixTupleClfrSrcAddrMask
       bits length. All other bits of diffServCountActOctetsHCnt in the augmented extension.

                 Discontinuities in mask, up to the value of this counter can occur
                 at re-initialization number needed
       to fill the length of the management system, and at
                 other times as indicated by address diffServSixTupleClfrSrcAddr are
       cleared to zero.  A zero bit in the value of
                 ifCounterDiscontinuityTime." mask then means that the
       corresponding bit in the address always matches."
    DEFVAL         {0}
    ::= { diffServCountActEntry 2 diffServSixTupleClfrEntry 7 }

          diffServCountActPktsCnt

diffServSixTupleClfrDscp OBJECT-TYPE
    SYNTAX       Counter32
              UNITS        "packets"         Dscp
    MAX-ACCESS   read-only     read-create
    STATUS         current
    DESCRIPTION
       "The number of Packets at the Action datapath element.
                 Meaning the packets has been classified and possibly
                 metered, and prior to any dropping process. This object
                 may be used on low speed interfaces, and represents the
                 least significant 32 bits of diffServCountActPktsHCount
                 in the augmented extension.

                 Discontinuities in the value of this counter can occur
                 at re-initialization of that the management system, and at
                 other times as indicated by DSCP in the packet must have to match this
       entry. A value of
                 ifCounterDiscontinuityTime." -1 indicates that a specific DSCP value has not
       been defined and thus all DSCP values are considered a match."
    DEFVAL         {-1}
    ::= { diffServCountActEntry 3 diffServSixTupleClfrEntry 8 }

          diffServCountActStatus

diffServSixTupleClfrProtocol OBJECT-TYPE
    SYNTAX       RowStatus         INTEGER (0..255)
    MAX-ACCESS     read-create
    STATUS         current
    DESCRIPTION
       "The RowStatus variable controls IP protocol to match against the activation,
                 deactivation, or deletion of this entry. Any writable
                 variable may be modified whether IPv4 protocol number in the row is active or
                 notInService."
       packet. A value of zero means match all."
    DEFVAL         {0}
    ::= { diffServCountActEntry 4 diffServSixTupleClfrEntry 9 }

          --
          -- High Capacity Counter Extension for Count Action Table
          --

          diffServCountActXTable

diffServSixTupleClfrDstL4PortMin OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServCountActXEntry         SixTupleClfrL4Port
    MAX-ACCESS   not-accessible     read-create
    STATUS         current
    DESCRIPTION
                 "This table contains the high capacity counters for
       "The minimum value that the
                 counters layer-4 destination port number in
       the Count Action Table.  These objects are
                 all 64-bit versions of the basic counters, having the
                 same basic semantics as their 32-bit counterparts, with
                 syntax extended packet must have in order to 64 bits."
              AUGMENTS { diffServCountActEntry } match this classifier entry."
    DEFVAL         {0}
    ::= { diffServAugments 1 diffServSixTupleClfrEntry 10 }

          diffServCountActXEntry

diffServSixTupleClfrDstL4PortMax OBJECT-TYPE
    SYNTAX       DiffServCountActXEntry         SixTupleClfrL4Port
    MAX-ACCESS   not-accessible     read-create
    STATUS         current
    DESCRIPTION
                 "An entry containing
       "The maximum value that the 64 bit counters applicable layer-4 destination port number in
       the packet must have in order to
                 a specific drop action entry."
              ::= { diffServActionXTable 1 }

          DiffServCountActXEntry match this classifier entry.
       This value must be equal to or greater that the value specified
       for this entry in diffServSixTupleClfrDstL4PortMin."
    DEFVAL         {65535}
    ::= SEQUENCE {
              diffServCountActOctetsHCnt     Counter64,
              diffServCountActPktsHCnt       Counter64 diffServSixTupleClfrEntry 11 }

          diffServCountActOctetsHCnt

diffServSixTupleClfrSrcL4PortMin OBJECT-TYPE
    SYNTAX       Counter64         SixTupleClfrL4Port
    MAX-ACCESS   read-only     read-create
    STATUS         current
    DESCRIPTION
       "The number of Octets at the Action datapath element.
                 Meaning the packets has been classified and possibly
                 metered, and prior to any dropping process.  This
                 object should be used on high speed interfaces.

                 Discontinuities in the minimum value of this counter can occur
                 at re-initialization of that the management system, and at
                 other times as indicated by layer-4 source port number in the value of
                 ifCounterDiscontinuityTime."
       packet must have in order to match this classifier entry."
    DEFVAL         {0}
    ::= { diffServCountActXEntry 1 diffServSixTupleClfrEntry 12 }

          diffServCountActPktsHCnt

diffServSixTupleClfrSrcL4PortMax OBJECT-TYPE
    SYNTAX       Counter64         SixTupleClfrL4Port
    MAX-ACCESS   read-only     read-create
    STATUS         current
    DESCRIPTION
       "The number of Packets at maximum value that the Action datapath element.
                 Meaning layer-4 source port number in the packets has been classified and possibly
                 metered, and prior
       packet must have in oder to any dropping process. match this classifier entry.  This
                 object should
       value must be used on high speed interfaces.

                 Discontinuities in equal to or greater that the value of specified for
       this counter can occur
                 at re-initialization of the management system, and at
                 other times as indicated by the value of
                 ifCounterDiscontinuityTime." entry in dsSixTupleIpSrcL4PortMin."
    DEFVAL         {65535}
    ::= { diffServCountActXEntry 2 diffServSixTupleClfrEntry 13 }

          -- Drop Action Table
          -- Rows of this table is pointed to by diffServAction to
          -- provide detail parameters specific to an Action Type.

          -- Notice

diffServSixTupleClfrStatus OBJECT-TYPE
    SYNTAX      RowStatus
    MAX-ACCESS  read-create
    STATUS     current
    DESCRIPTION
       "The RowStatus variable controls the use of diffServQueueId as part activation, deactivation, or
       deletion of this
          -- table's index.  Hence each entry is queue specific.

          -- This object allows a configuring system to obtain a
          -- unique value for diffServDropActId for purposes of
          -- configuration.

          diffServDropActUnique classifier. Any writable variable may be modified
       whether the row is active or notInService."
    ::= { diffServSixTupleClfrEntry 14 }

diffServSixTupleClfrUnique OBJECT-TYPE
    SYNTAX       TestAndIncr
    MAX-ACCESS   read-write
    STATUS       current
    DESCRIPTION
       "The diffServDropActUnique diffServSixTupleClfrUnique object yields a unique new
       value for diffServDropActId diffServSixTupleClfrId when read and subsequently
       set. This value must be tested for uniqueness." uniqueness and can
       be used by a configuring system to obtain a
       unique value for diffServSixTupleClfrId for purposes of
       row creation in the diffServSixTupleClfrTable."
    ::= { diffServObjects 6 2 }
          diffServDropActTable

--
-- 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 OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServDropActEntry DiffServMeterEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
                 "The drop action
       "This table enumerates sets of attributes
                 used to represent generic meters that a drop process.  Each set is normally
                 associated with system may use to
       police a queue.  The entries stream of this table is
                 meant classified traffic.  The traffic stream to be referenced
       metered is determined by the diffServAction attribute classifier upstream of entries the meter
       i.e. by the object(s) that point to each entry in diffServActionTable.  The entries of this table is used for:  Tail Drop Action when
                 diffServActionType = tailDrop Random Drop Action when
                 diffServActionType = randomDrop Deterministic Drop
                 Action when diffServActionType = deterDrop"
       using a RowPointer. This may include all traffic on an interface.

       Specific meter details are to be found in diffServMeterSpecific."
           REFERENCE
               "[MODEL] section 5.1"
    ::= { diffServTables 6 3 }

          diffServDropActEntry

diffServMeterEntry OBJECT-TYPE
    SYNTAX       DiffServDropActEntry       DiffServMeterEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the drop action meter table describes describing a single
                 drop process's configuration.  For Tail Drop Process:

                 For Random Drop Process:  (QMin,PMin) and (QMax,PMax)
                 defines the drop probability used for the random drop
                 process.  Normally PMin have a value of zero.  QClip
                 defines the guaranteed average queue depth, after which
                 the drop probability reaches 100%.  For Deterministic
                 Drop Process:  QMeasure points to an entry providing
                 Queue Measurement needed for the drop process." meter."
    INDEX { diffServQueueId, diffServDropActId ifIndex, diffServMeterIfDirection,
            diffServMeterId  }
    ::= { diffServTable diffServMeterTable 1 }

          DiffServDropActEntry

DiffServMeterEntry ::= SEQUENCE  {
              diffServDropActId               Unsigned32,
              diffServDropActQMin             Unsigned32,
              diffServDropActQMax             Unsigned32,
              diffServDropActQClip            Unsigned32,
              diffServDropActPMin             Unsigned32,
              diffServDropActPMax             Unsigned32,
              diffServDropActPCur             Unsigned32,
              diffServDropActQMeasure
    diffServMeterIfDirection       IfDirection,
    diffServMeterId                INTEGER,
    diffServMeterSucceedNext       RowPointer,
              diffServDropActOctetsCnt        Counter32,
              diffServDropActPktsCnt          Counter32,
              diffServDropActStatus
    diffServMeterFailNext          RowPointer,
    diffServMeterSpecific          OBJECT IDENTIFIER,
    diffServMeterStatus            RowStatus
}
          diffServDropActId

diffServMeterIfDirection OBJECT-TYPE
    SYNTAX       Unsigned32 (1..2147483647)       IfDirection
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
                 "Drop Action Id enumerates the Drop Action entry."
              ::= { diffServDropActEntry 1 }

          diffServDropActQMin OBJECT-TYPE
              SYNTAX       Unsigned32
              UNITS        "Kilo Bits"
              MAX-ACCESS   read-create
              STATUS       current
              DESCRIPTION
                 "QMin, with PMin, defines
       "Specifies the lowerest drop probability
                 point direction for this random drop process.  With PMin=0, the
                 queue may drop if a packet is presented to it and meter entry on the
                 average queue depth exceeds QMin." interface."
    ::= { diffServDropActEntry 2 diffServMeterEntry 1 }

          diffServDropActQMax

diffServMeterId OBJECT-TYPE
    SYNTAX       Unsigned32
              UNITS        "Kilo Bits"       INTEGER (0..2147483647)
    MAX-ACCESS   read-create   not-accessible
    STATUS       current
                 "QMax, with PMax, defines the higher point of drop
                 probability for random drop process.  For Tail Drop
                 Process:  This represents the measure by which the
                 queue will drop if a packet is presented to it."
    DESCRIPTION
       "This identifies a meter entry."
    ::= { diffServDropActEntry 3 diffServMeterEntry 2 }

          diffServDropActQClip

diffServMeterSucceedNext OBJECT-TYPE
    SYNTAX       Unsigned32
              UNITS        "Kilo Bits"       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
                 "The average queue length at which point
    DESCRIPTION
       "If the drop
                 probability reaches 100%." traffic does conform to the meter, this indicates the
       next datapath element to handle the traffic e.g. an Action or
       another Meter datapath element.  The value zeroDotZero in this
       variable indicates no further Diffserv treatment is performed on
       this traffic by the current interface for this interface
       direction."
    DEFVAL      { zeroDotZero }
    ::= { diffServDropActEntry 4 diffServMeterEntry 3 }

          diffServDropActPMin

diffServMeterFailNext OBJECT-TYPE
    SYNTAX       Unsigned32 (0..1000000)
              UNITS        "per-micro-age"       RowPointer
    MAX-ACCESS   read-write   read-create
    STATUS       current
                 "QMin, with PMin, defines
    DESCRIPTION
       "If the lowerest drop probability
                 point for traffic does not conform to the meter, this random drop process.  With PMin=0, indicates the
                 queue may drop if a packet is presented
       next datapath element to it and the
                 average queue depth exceeds QMin.  This drop
                 probability is expressed in per-micro-age, handle the traffic e.g. an Action or
       Meter datapath element.  The value zeroDotZero in this attribute needs to be divided variable
       indicates no further Diffserv treatment is performed on this
       traffic by 1,000,000 to
                 obtain the drop probability between 0 and 1." current interface for this interface direction."
    DEFVAL      { zeroDotZero }
    ::= { diffServDropActEntry 5 diffServMeterEntry 4 }

          diffServDropActPMax

diffServMeterSpecific OBJECT-TYPE
    SYNTAX       Unsigned32 (0..1000000)
              UNITS        "per-micro-age"       OBJECT IDENTIFIER
    MAX-ACCESS   read-write   read-create
    STATUS       current
                 "QMax and PMax are part of
    DESCRIPTION
       "This indicates the drop probability
                 configuration.  This drop probability is expressed in
                 per-micro-age, behaviour of the value in this attribute needs meter by pointing to an
       object containing detailed parameters. One example of a valid
       object would be
                 divided diffServTBMeterTable, whose entries are indexed
       by 1,000,000 to obtain the drop probability
                 between 0 and 1." same variables as this table, for describing an instance
       of a token-bucket meter."
    ::= { diffServMeterEntry 5 }

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

          diffServDropActPCur

diffServMeterUnique OBJECT-TYPE
    SYNTAX       Unsigned32 (0..1000000)
              UNITS        "per-micro-age"       TestAndIncr
    MAX-ACCESS   read-only   read-write
    STATUS       current
    DESCRIPTION
       "The current drop probability. diffServMeterUnique object yields a unique new value for
       diffServMeterId when read and subsequently set.  This drop probability
                 is expressed in per-micro-age, the value in this
                 attribute needs to must
       be tested for uniqueness and can be divided used by 1,000,000 a configuring system
       to obtain a unique value for diffServMeterId for purposes of row
       creation in the drop probability between 0 and 1." diffServMeterTable."
    ::= { diffServDropActEntry 7 diffServObjects 3 }

          diffServDropActQMeasure

--
-- Token-Bucket Meter Table
--

diffServTBMeterTable OBJECT-TYPE
    SYNTAX       RowPointer       SEQUENCE OF DiffServTBMeterEntry
    MAX-ACCESS   read-create   not-accessible
    STATUS       current
                 "Points
    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 if a multi-rate
       token bucket is needed for a given Per-Hop Behavior. One example
       of such a PHB might be for an entry in the diffServQMeasureTable AF implementation.  This is not
       meant to imply that cascading of such elements is functionally
       equivalent to a multi-rate meter, it is merely a convenience for
                 queue information required by
       this MIB representation.

       Entries in this table share indexing with those in the drop process." base
       diffServTBMeterTable: they appear in and are deleted from this
       table whenever they "
    REFERENCE
        "[MODEL] section 5.1.3"
    ::= { diffServDropActEntry 8 diffServTables 4 }

          diffServDropActOctetsCnt

diffServTBMeterEntry OBJECT-TYPE
    SYNTAX       Counter32       DiffServTBMeterEntry
    MAX-ACCESS   read-only   not-accessible
    STATUS       current
    DESCRIPTION
                 "The number of octets
       "An entry that have been dropped by describes a drop
                 process.  On high speed devices, this object implements
                 the least significant 32 bits of
                 diffServDropActOctetsHCnt.

                 Discontinuities in the value of this counter can occur
                 at re-initialization of the management system, and at
                 other times as indicated single token-bucket meter, indexed by
       the value of
                 ifCounterDiscontinuityTime." same variables as a diffServMeterEntry."
    INDEX { ifIndex, diffServMeterIfDirection,
            diffServMeterId  }
    ::= { diffServTBMeterTable 1 }

DiffServTBMeterEntry ::= SEQUENCE  {
    diffServTBMeterRate              Unsigned32,
    diffServTBMeterBurstSize         BurstSize,
    diffServTBMeterStatus            RowStatus
}

diffServTBMeterRate OBJECT-TYPE
    SYNTAX       Unsigned32
    UNITS        "kilobits per second"
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The token-bucket rate, in kilobits per second (kbps)."
    ::= { diffServDropActEntry 9 diffServTBMeterEntry 1 }

          diffServDropActPktsCnt

diffServTBMeterBurstSize OBJECT-TYPE
    SYNTAX       Counter32       BurstSize
    UNITS        "Bytes"
    MAX-ACCESS   read-only   read-create
    STATUS       current
    DESCRIPTION
       "The maximum number of packets that have been dropped by a drop
                 process.  On high speed devices, this object implements
                 the least significant 32 bits of
                 diffServDropActPktsHCnt.

                 Discontinuities bytes in a single transmission burst.  The
       interval over which the value of this counter burst is to be measured can occur
                 at re-initialization of the management system, and at
                 other times be derived as indicated by the value of
                 ifCounterDiscontinuityTime."
       diffServTBMeterBurstSize*8*1000/diffServTBMeterRate."
    ::= { diffServDropActEntry 10 diffServTBMeterEntry 2 }

          diffServDropActStatus

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

--
-- High Capacity Counter Extension for Drop Actions
--

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

          diffServDropActXTable

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

       Specific actions are indicated by diffServActionSpecific which
       points to another object which describes the
                 counters action in further
       detail."
    REFERENCE
        "[MODEL] section 6."
    ::= { diffServTables 5 }

diffServActionEntry OBJECT-TYPE
    SYNTAX       DiffServActionEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the Drop Action Table.  These objects are
                 all 64 bit versions of the basic counters, having action table describing the
                 same basic semantics as their 32-bit counterparts, with
                 syntax extended actions applied to 64 bits."
              AUGMENTS
       traffic arriving at its input."
    INDEX { ifIndex, diffServActionIfDirection,
            diffServActionId }
    ::= { diffServActionTable 1 }

DiffServActionEntry ::= SEQUENCE  { diffServDropActEntry
    diffServActionIfDirection       IfDirection,
    diffServActionId                INTEGER,
    diffServActionNext              RowPointer,
    diffServActionSpecific          RowPointer,
    diffServActionStatus            RowStatus
}

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

          diffServDropActXEntry

diffServActionId OBJECT-TYPE
    SYNTAX       DiffServDropActXEntry       INTEGER (0..2147483647)
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
                 "An entry containing
       "Action Id enumerates the 64 bit counters applicable to
                 a specific drop action Action entry."
    ::= { diffServDropActXTable 1 }

          DiffServDropActXEntry ::= SEQUENCE  {
              diffServDropActOctetsHCnt       Counter64,
              diffServDropActPktsHCnt         Counter64 diffServActionEntry 2 }

          diffServDropActOctetsHCnt

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

                 Discontinuities in Next pointer indicates the next datapath element to handle
       the traffic.  For example, a queue datapath element.  The value of
       zeroDotZero in this counter can occur
                 at re-initialization of the management system, and at
                 other times as indicated variable indicates no further DiffServ
       treatment is performed on this flow by the value of
                 ifCounterDiscontinuityTime." current interface for
       this interface direction."
    DEFVAL      { zeroDotZero }
    ::= { diffServDropActXEntry 1 diffServActionEntry 3 }

          diffServDropActPktsHCnt

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

                 Discontinuities in MIB table providing additional information for the value of this counter can occur
                 at re-initialization
       type of the management system, and at
                 other times as action indicated by this action table entry.

       For the value standard actions defined by this MIB module, this should
       point to an entry in one of
                 ifCounterDiscontinuityTime." the diffServDscpMarkActTable,
       diffServCountActTable tables or to the diffServAbsoluteDropAction
       OID.  For other actions, it may point to a table defined in some
       other MIB."
    ::= { diffServDropActXEntry 2 diffServActionEntry 4 }
          -- This object allows a configuring system to obtain a
          -- unique value for diffServActionId for purposes

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

diffServActionUnique OBJECT-TYPE
    SYNTAX       TestAndIncr
    MAX-ACCESS   read-write
    STATUS       current
    DESCRIPTION
       "The diffServActionUnique object yields a unique new value for
       diffServActionId when read and subsequently set.  This value must
       be tested for uniqueness." uniqueness.  This object allows a configuring
       system to obtain a unique value for diffServActionId for purposes
       of row creation."
    ::= { diffServObjects 7 4 }

-- The DSCP Mark Action Table allows us to enumerate the different
-- types
-- Rows of actions this table are pointed to be applied by diffServAction to a flow.

          diffServActionTable
-- provide detailed parameters specific to the DSCP
-- Mark action.

diffServDscpMarkActTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServActionEntry DiffServDscpMarkActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
                 "The Action Table
       "This table enumerates actions that can be
                 performed to a stream of traffic.  Multiple Actions can
                 be concatenated.  For example, specific DSCPs used for marking or
       remarking the DSCP field of a stream IP packets.  The entries of
                 traffic exiting this
       table may be referenced by a meter (conforming or non-conforming),
                 then perform diffServActionSpecific attribute
       that points to diffServDscpMarkActTable."
    REFERENCE
        "[MODEL] section 6.1"
    ::= { diffServTables 6 }

diffServDscpMarkActEntry OBJECT-TYPE
    SYNTAX       DiffServDscpMarkActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the DSCP mark action table describes a drop process with dropped traffic counts
                 maintained.  Notice counting single DSCP
       used for marking."
    INDEX { diffServDscpMarkActDscp }
    ::= { diffServDscpMarkActTable 1 }

DiffServDscpMarkActEntry ::= SEQUENCE  {
    diffServDscpMarkActDscp          Dscp
}

diffServDscpMarkActDscp OBJECT-TYPE
    SYNTAX       Dscp
    MAX-ACCESS   read-only
    STATUS       current
    DESCRIPTION
       "The DSCP that this Action uses for marking/remarking traffic.
       Note that it is considered as quite possible that the only packets subject to
       this Action are already marked with this DSCP.

       Diffserv may result in packet remarking both on ingress to a type of
                 action.  The set of flow specific counters
       network and on egress and it is quite possible that ingress and
       egress would occur in the same router."
    ::= { diffServDscpMarkActEntry 1 }

--
-- Count Action Table maintains statistics
--

diffServCountActTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServCountActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "This table contains counters for a flow that
                 arrives to this Action datapath element.  This count is
                 always taken before any drop processing is performed." all the traffic passing through
       an action element."
    REFERENCE
        "[MODEL] section 6.5"
    ::= { diffServTables 7 }

          diffServActionEntry

diffServCountActEntry OBJECT-TYPE
    SYNTAX       DiffServActionEntry       DiffServCountActEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the count action table describes the actions
                 applied to a single set of
       traffic exiting counters. This entry is indexed in the same way as a given meter."
       diffServActionEntry.  An entry should exist in this table for
       every diffServActionEntry that has a diffServActionSpecific
       pointing to this table."
    INDEX { ifIndex, diffServInterfaceDirection, diffServActionIfDirection,
            diffServActionId }
    ::= { diffServActionTable diffServCountActTable 1 }

          DiffServActionEntry

DiffServCountActEntry ::= SEQUENCE  {
              diffServActionId                Unsigned32,
              diffServActionNext              RowPointer,
              diffServActionType              INTEGER,
              diffServAction                  RowPointer,
              diffServActionStatus
    diffServCountActOctets       Counter32,
    diffServCountActHCOctets     Counter64,
    diffServCountActPkts         Counter32,
    diffServCountActHCPkts       Counter64,
    diffServCountActStatus       RowStatus
}

          diffServActionId

diffServCountActOctets OBJECT-TYPE
    SYNTAX       Unsigned32 (1..2147483647)       Counter32
    MAX-ACCESS   not-accessible   read-only
    STATUS       current
    DESCRIPTION
                 "Action Id enumerates
       "The number of octets at the Action entry." datapath element.  On high
       speed devices, this object implements the least significant 32
       bits of diffServcountActHCOctets.

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

          diffServActionNext

diffServCountActHCOctets OBJECT-TYPE
    SYNTAX       RowPointer       Counter64
    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 this variable
                 indicates no further DiffServ treatment is performed  This
       object should be used on high speed interfaces.

       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 for this interface
                 direction."
              DEFVAL      { zeroDotZero }
              ::= { diffServActionEntry 2 }

          diffServActionType OBJECT-TYPE
              SYNTAX       INTEGER {
                               other(1),      -- types not specified here.
                               mark(2),       -- mark or remark
                               count(3),      -- count
                               alwaysDrop(4), -- disallow traffic
                               tailDrop(5),   -- fix queue size Drop
                               randomDrop(6), -- Random Drop
                               deterDrop(7)   -- Deterministic Drop value of ifCounterDiscontinuityTime appropriate
       to this interface."
    ::= { diffServCountActEntry 2 }

diffServCountActPkts OBJECT-TYPE
    SYNTAX       Counter32
    MAX-ACCESS   read-write   read-only
    STATUS       current
    DESCRIPTION
                 "Indicates
       "The number of packets at the type Action datapath element.  On high
       speed devices, this object implements the least significant 32
       bits of action diffServAction points
                 to." diffServcountActHCPkts.

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

          diffServAction

diffServCountActHCPkts OBJECT-TYPE
    SYNTAX       RowPointer       Counter64
    MAX-ACCESS   read-create   read-only
    STATUS       current
    DESCRIPTION
                 "Points to a row in a Action Type Table that provides
                 all
       "The number of packets at the parameters for Action datapath element.  This
       object should be used on high speed interfaces.

       Discontinuities in the type value of action indicated in
                 diffServActionType.  Can also points to a row in some this counter can occur at re-
       initialization of the management system and at other MIB times as
       indicated by the value of ifCounterDiscontinuityTime appropriate
       to provide some proprietary action type." this interface."
    ::= { diffServActionEntry diffServCountActEntry 4 }

          diffServActionStatus

diffServCountActStatus OBJECT-TYPE
    SYNTAX       RowStatus
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The RowStatus variable controls the activation, deactivation, or
       deletion of a meter. Any writable
                 variable may be modified whether the row is active or
                 notInService."
              ::= { diffServActionEntry 5 }
          --
          -- Queue Set Table
          -- The Queue Set Table is used for organizing queues
          -- defined in the Queue Table into Queue Sets, with
          -- queue scheduling defined in the queue set this entry.
          -- Queue Set Table provides flexibility in queue
          -- organization and allows more complex hierarchical
          -- scheduling algorithms be defined.  For example,
          -- multiple scheduling algorithms, each with multiple
          -- queues, used on the same logical/physical interface.
          --

          -- This object allows a configuring system to obtain a
          -- unique value for diffServQSetId for purposes of
          -- configuration

          diffServQSetUnique OBJECT-TYPE
              SYNTAX       TestAndIncr
              MAX-ACCESS   read-write Any writable variable may be modified
       whether the row is active or notInService."
    ::= { diffServCountActEntry 5 }

diffServAbsoluteDropAction OBJECT-IDENTITY
    STATUS       current
    DESCRIPTION
                 "The diffServQSetUnique
       "This object yields a unique new
                 value for diffServQSetId when read and subsequently
                 set. This identifier may be used as the value must of a
       diffServActionSpecific pointer in order to indicate that all
       packets following this path are to be tested for uniqueness." dropped unconditionally at
       this point. It is likely, but not required, that this action will
       be preceded by a counter action."
    ::= { diffServObjects 8 6 }

          diffServQSetTable

--
-- Algorithmic Drop Table
--

diffServAlgDropTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServQSetEntry DiffServAlgDropEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Queue Set Table enumerates the queue sets.  Queue
                 Sets are used to organize queues based on their
                 scheduling algorithms.  Multiple sheduling algorithms
                 can be used, with each algorithm described by one Queue
                 Set Entry.  Multiple instances of algorithmic drop table contains entries describing a single sheduling
                 algorithm, each with different scheduling parameters
                 can also be expressed, each described by its own Queue
                 Set Entry.  Relationships between Queue Sets are used process
       that drops packets according to build scheduling algorithm hierarchies.  For
                 example, a weighed fair queueing queue set can be a
                 part of a priority queueing queue set, having the
                 weighed fair queueing queue set be a branch of the
                 priority queueing queue set.  More complex hierarchies
                 can also be expressed using this mechanism." some algorithm."
    REFERENCE
        "[MODEL] section 7.1.3"
    ::= { diffServTables 8 }
          diffServQSetEntry

diffServAlgDropEntry OBJECT-TYPE
    SYNTAX       DiffServQSetEntry       DiffServAlgDropEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the Queue Set Table describes a single
                 queue set." process that drops packets according to
       some algorithm.  Algorithms described here include: tailDrop(2),
       headDrop(3) and other(1).

       Specifically, Random Drop algorithms are not directly represented
       in this MIB but can be indicated by an entry in this table with
       diffServAlgDropType of other(1) and extensions, pointed to by
       diffServAlgDropSpecific, in some other MIB module that parallels
       entries in this table e.g. by using the same index attribute(s)."
    INDEX { ifIndex, diffServInterfaceDirection,
                      diffServQSetId diffServAlgDropIfDirection,
            diffServAlgDropId }
    ::= { diffServQSetTable diffServAlgDropTable 1 }

          DiffServQSetEntry

DiffServAlgDropEntry ::= SEQUENCE  {
              diffServQSetId                   Unsigned32,
              diffServQSetParentId             Unsigned32,
              diffServQSetWeight               Unsigned32,
              diffServQSetMethod
    diffServAlgDropIfDirection      IfDirection,
    diffServAlgDropId               INTEGER,
              diffServQSetRateUnit
    diffServAlgDropType             INTEGER,
              diffServQSetMinRate              Unsigned32,
              diffServQSetMaxRate              Unsigned32,
              diffServQSetNext
    diffServAlgDropNext             RowPointer,
    diffServAlgDropQMeasure         RowPointer,
              diffServQSetStatus
    diffServAlgDropQThreshold       Unsigned32,
    diffServAlgDropSpecific         OBJECT IDENTIFIER,
    diffServAlgDropOctets           Counter32,
    diffServAlgDropHCOctets         Counter64,
    diffServAlgDropPkts             Counter32,
    diffServAlgDropHCPkts           Counter64,
    diffServAlgDropStatus           RowStatus
}

          diffServQSetId

diffServAlgDropIfDirection OBJECT-TYPE
    SYNTAX       IfDirection
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "Specifies the direction for this algorithmic dropper entry on
       the interface."
    ::= { diffServAlgDropEntry 1 }

diffServAlgDropId OBJECT-TYPE
    SYNTAX       Unsigned32 (1..2147483647)       INTEGER (0..2147483647)
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
                 "The Queue Set
       "Drop Action Id enumerates the Queue Set Drop Action entry."
    ::= { diffServQSetEntry 1 diffServAlgDropEntry 2 }

          diffServQSetParentId

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

       The tailDrop(2) algorithm is described as follows:
       diffServAlgDropQThreshold represents the formation depth of
                 hierarchical relationships between scheduling
                 algorithms." the queue
       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
       diffServAlgDropQMeasure is at diffServAlgDropQThreshold, the
       packet currently at the head of the queue is dropped and the new
       packet is enqueued at the tail of the queue."
    ::= { diffServQSetEntry 2 diffServAlgDropEntry 3 }

          diffServQSetWeight

diffServAlgDropNext OBJECT-TYPE
    SYNTAX       Unsigned32       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
                 "Used with QSetParentId in hierarchical scheduling
                 setup.  QSetWeight represent
       "The Next pointer indicates the weight of all queues
                 within this queue set, with respect next datapath element to queues in other handle
       the traffic e.g. a queue sets datapath element.  The value zeroDotZero
       in hierarchical scheduling.  For example, this queue set represents the weighed fair queueing
                 scheduling amongst all variable indicates no further DiffServ treatment is
       performed on this flow by the queues in current interface for this queue set.
                 This set of weighted fair queueing queues as a whole
                 belongs
       interface direction."
    ::= { diffServAlgDropEntry 4 }

diffServAlgDropQMeasure OBJECT-TYPE
    SYNTAX       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "Points to a priority queueing queue set.  QSetWeight
                 determines this queue set's priority/weight an entry in the
                 parent diffServQueueTable to indicate the
       queue set's priority queueing scheduling
                 algorithm.  There can be more than one weighed fair
                 queueing that a drop algorithm is to monitor when deciding whether
       to drop a packet."
    ::= { diffServAlgDropEntry 5 }

diffServAlgDropQThreshold OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "A threshold on the depth of the queue sets belonging being measured at which a
       trigger is generated to the same priority
                 queueing parent dropping algorithm.

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

          diffServQSetMethod

diffServAlgDropSpecific OBJECT-TYPE
    SYNTAX       INTEGER {
                               other(1), -- not listed here
                               pq(2),    -- Priority Queueing
                               wfq(3),   -- Weighed Fair Queueing
                               wrr(4)    -- Weighed Round Robin
                           }       OBJECT IDENTIFIER
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
                 "The scheduling
       "Points to a table (not an entry in the table) defined elsewhere
       that provides further detail regarding a drop algorithm used described
       as diffServAlgDropType other(1). entries in such a table are to
       be indexed by queues the same variables as this diffServAlgDropEntry.

       For algorithms specified fully in this queue
                 set." MIB module, this should
       take the value zeroDotzero."
    ::= { diffServQSetEntry 4 diffServAlgDropEntry 7 }

          diffServQSetRateUnit

diffServAlgDropOctets OBJECT-TYPE
    SYNTAX       INTEGER {
                               kbps(1),    -- kilo bits per second
                               packets(2)  -- packets per second
                           }       Counter32
    MAX-ACCESS   read-create   read-only
    STATUS       current
    DESCRIPTION
       "The unit number of measure for octets that have been dropped by this drop
       process.  On high speed devices, this object implements the MinRate and MaxRate
                 attributes.  The packet unit allows packet fair
                 algorithms least
       significant 32 bits of diffServAlgDropHCOctets.

       Discontinuities in addition 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 bit fair algorithms." this interface."
    ::= { diffServQSetEntry 5 diffServAlgDropEntry 8 }

          diffServQSetMinRate

diffServAlgDropHCOctets OBJECT-TYPE
    SYNTAX       Unsigned32
              UNITS        "KBPS"       Counter64
    MAX-ACCESS   read-create   read-only
    STATUS       current
    DESCRIPTION
       "The minimum rate for the whole queue set.  If number of octets that have been dropped by this drop
       process.  This object should be used on high speed interfaces.

       Discontinuities in the value is zero, then there is effectively no minimum
                 rate.  If of this counter can occur at re-
       initialization of the value is non-zero, management system and at other times as
       indicated by the queue set will
                 seek to assure this class value of traffic at least ifCounterDiscontinuityTime appropriate
       to this
                 rate." interface."
    ::= { diffServQSetEntry 6 diffServAlgDropEntry 9 }

          diffServQSetMaxRate

diffServAlgDropPkts OBJECT-TYPE
    SYNTAX       Unsigned32
              UNITS        "KBPS"       Counter32
    MAX-ACCESS   read-create   read-only
    STATUS       current
    DESCRIPTION
       "The maximum rate for the whole queue set.  If number of packets that have been dropped by this drop
       process.  On high speed devices, this object implements the
                 value is zero, then there is effectively no maximum
                 rate.  If least
       significant 32 bits of diffServAlgDropHCPkts.

       Discontinuities in the value is non-zero, the queue set will
                 seek to assure of this class counter can occur at re-
       initialization of traffic the management system and at most other times as
       indicated by the value of ifCounterDiscontinuityTime appropriate
       to this
                 rate." interface."
    ::= { diffServQSetEntry 7 diffServAlgDropEntry 10 }

          diffServQSetNext

diffServAlgDropHCPkts OBJECT-TYPE
    SYNTAX       RowPointer       Counter64
    MAX-ACCESS   read-create   read-only
    STATUS       current
    DESCRIPTION
                 "Selects the next data path component, which can be
                 another Queue Set.  One usage
       "The number of multiple serial Queue
                 Sets is for Class Base Queueing (CBQ).  The value
                 zeroDotZero in this variable indicates no further
                 DiffServ treatment is performed on this flow packets that have been dropped by the
                 current interface for this interface direction.  For
                 example, for an inbound interface drop
       process.  This object should be used on high speed interfaces.

       Discontinuities in the value zeroDotZero
                 indicates that of this counter can occur at re-
       initialization of the packet flow has now completed
                 inbound DiffServ treatment management system and should be forwarded on
                 to at other times as
       indicated by the value of ifCounterDiscontinuityTime appropriate outbound
       to this interface."
              DEFVAL       { zeroDotZero }
    ::= { diffServQSetEntry 8 diffServAlgDropEntry 11 }

          diffServQSetStatus

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

--
          -- Queue Table
          --

          -- This object allows a configuring system to obtain a
-- unique value for diffServQId diffServAlgDropId for purposes of
-- configuration.

          diffServQUnique

diffServAlgDropUnique OBJECT-TYPE
    SYNTAX       TestAndIncr
    MAX-ACCESS   read-write
    STATUS       current
    DESCRIPTION
                 "The diffServQUnique
       "This object yields a unique new
       value for diffServQId diffServAlgDropId when read and subsequently
       set. This value must be tested for uniqueness." uniqueness and can
       be used by a configuring system to obtain a
       unique value for diffServAlgDropId for purposes of
       row creation in the diffServAlgDropTable."
    ::= { diffServObjects 9 }

          -- The Queue Table allows us to describe individual queues 7 }

--
-- Queue Table
--

diffServQTable OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServQEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Queue Table enumerates the individual queues on an
       interface."
    ::= { diffServTables 9 }

diffServQEntry OBJECT-TYPE
    SYNTAX       DiffServQEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the Queue Table describes a single FIFO
                 queue." queue in one
       direction on an interface."
    INDEX { diffServQQSetId, ifIndex, diffServQIfDirection, diffServQId }
    ::= { diffServQTable 1 }

DiffServQEntry ::= SEQUENCE  {
    diffServQIfDirection             IfDirection,
    diffServQId                      INTEGER,
    diffServQNext                    RowPointer,
    diffServQPriority                Unsigned32,
    diffServQMinRateAbs              Unsigned32,
              diffServQQSetId
    diffServQMinRateRel              Unsigned32,
              diffServQSchedulerWeight
    diffServQMaxRateAbs              Unsigned32,
    diffServQMaxRateRel              Unsigned32,
    diffServQStatus                  RowStatus
}

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

diffServQId OBJECT-TYPE
    SYNTAX       Unsigned32 (1..2147483647)       INTEGER (0..2147483647)
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Queue Id enumerates the Queue entry." Queue entry."
    ::= { 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."
    ::= { 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 }

diffServQMinRateAbs 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 effectively no minimum rate guarantee.  If
       the value is non-zero, the scheduler will assure the servicing of
       this queue to at least this rate.

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

         diffServQMinRateRel = diffServQMinRateAbs * 10,000,000/ifSpeed

       or, if appropriate:

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

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

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

         diffServQMinRateAbs = ifSpeed * diffServQMinRateRel/10,000,000

       or, if appropriate:

         diffServQMinRateAbs = ifHighSpeed * diffServQMinRateRel / 10"
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]"
    ::= { diffServQEntry 1 6 }

          diffServQQSetId

diffServQMaxRateAbs OBJECT-TYPE
    SYNTAX       Unsigned32 (1..2147483647)
    UNITS        "kilobits per second"
    MAX-ACCESS   not-accessible   read-create
    STATUS       current
    DESCRIPTION
                 "Indicates
       "The maximum rate in kilobits/sec that a downstream scheduler
       element should allocate to this queue. If the Queue Set value is zero, then
       there is effectively no maximum rate limit and that the scheduler
       should attempt to be work-conserving for this queue.  If the
       value is non-zero, the scheduler will limit the servicing of this
       queue to, at most, this rate in a non-work-conserving manner.

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

         diffServQMaxRateRel = diffServQMaxRateAbs * 10,000,000/ifSpeed

       or, if appropriate:

         diffServQMaxRateRel = diffServQMaxRateAbs * 10 / ifHighSpeed"
    REFERENCE
        "ifSpeed, ifHighSpeed from [IFMIB]"
    ::= { diffServQEntry 2 7 }

          diffServQSchedulerWeight

diffServQMaxRateRel OBJECT-TYPE
    SYNTAX       Unsigned32
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The weight or priority of the maximum rate that a downstream scheduler element should
       allocate to this queue, depending on the
                 scheduling method used.  Notice only relative to the weight maximum rate of the
                 queue is used, instead
       interface as reported by ifSpeed or ifHighSpeed, in units of
       1/10,000 of 1.  If the rate.  The value is zero, then there is effectively
       no maximum rate can limit and the scheduler should attempt to be
                 derived based on
       work-conserving for this queue.  If the rate of value is non-zero, the
       scheduler will limit the servicing of this queue set.  This to, at most,
       this rate in a non-work-conserving manner.

       Note that this attribute's value is coupled to
                 facilitate changing link speed and/or changing
                 scheduling method without reconfiguring that of
       diffServQMaxRateAbs: changes to one will affect the queues." 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]"
    ::= { diffServQEntry 3 8 }

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

          -- Queue Measurement Table

          -- This object allows a configuring system to obtain a
          -- unique value for diffServQMeasureId for purposes of
          -- configuration.

          diffServQMeasureUnique the row is active or notInService."
    ::= { diffServQEntry 9 }

diffServQUnique OBJECT-TYPE
    SYNTAX       TestAndIncr
    MAX-ACCESS   read-write
    STATUS       current
    DESCRIPTION
       "The diffServQMeasureUnique diffServQUnique object yields a unique new value for diffServQMeasureId
       diffServQId when read and subsequently set.  This value must be
       tested for uniqueness." uniqueness and can be used by a configuring system to
       obtain a unique value for diffServQId for purposes of row
       creation in the diffServQTable."
    ::= { diffServObjects 10 8 }

          diffServQMeasureTable

--
-- 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 OBJECT-TYPE
    SYNTAX       SEQUENCE OF DiffServQMeasureEntry DiffServSchedulerEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "The Queue Measurement Scheduler Table contains entries
                 describing the state of queues, this include states for
                 implementing traffic treatment algorithms.  Notice
                 multiple queue measurement entries for the same queue
                 is allowed." enumerates packet schedulers.  Multiple
       scheduling algorithms can be used on a given interface, with each
       algorithm described by one diffServSchedulerEntry."
    REFERENCE
        "[MODEL] section 7.1.2"
    ::= { diffServTables 10 }

          diffServQMeasureEntry

diffServSchedulerEntry OBJECT-TYPE
    SYNTAX       DiffServQMeasureEntry       DiffServSchedulerEntry
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
       "An entry in the Queue Measure Scheduler Table describes describing a single
                 set instance of measurement for
       a specific queue." scheduling algorithm."
    INDEX { diffServQMeasureQId, diffServQMeasureId ifIndex, diffServSchedulerIfDirection,
            diffServSchedulerId }
    ::= { diffServQMeasureTable diffServSchedulerTable 1 }

          DiffServQMeasureEntry

DiffServSchedulerEntry ::= SEQUENCE  {
              diffServQMeasureId               Unsigned32,
              diffServQMeasureQId              Unsigned32,
              diffServQMeasureAvgSampleInt     Unsigned32,
              diffServQMeasureAvgWeightExp     Unsigned32,
              diffServQMeasureAvgWeightMan     Unsigned32,
              diffServQMeasureQAverage         Unsigned32,
              diffServQMeasureStatus
    diffServSchedulerIfDirection          IfDirection,
    diffServSchedulerId                   INTEGER,
    diffServSchedulerMethod               INTEGER,
    diffServSchedulerNext                 RowPointer,
    diffServSchedulerStatus               RowStatus
}

          diffServQMeasureId

diffServSchedulerIfDirection OBJECT-TYPE
    SYNTAX       Unsigned32 (1..2147483647)  IfDirection
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
                 "The Queue Measure Id enumerates
       "Specifies the Queue Measure
                 entry." direction for this scheduler entry on the
       interface."
    ::= { diffServQMeasureEntry diffServSchedulerEntry 1 }

          diffServQMeasureQId

diffServSchedulerId OBJECT-TYPE
    SYNTAX       Unsigned32 (1..2147483647)       INTEGER (0..2147483647)
    MAX-ACCESS   not-accessible
    STATUS       current
    DESCRIPTION
                 "Indicates
       "The Scheduler Id enumerates the queue this measurement is associated
                 with." Scheduler entry."
    ::= { diffServQMeasureEntry diffServSchedulerEntry 2 }

          diffServQMeasureAvgSampleInt

diffServSchedulerMethod OBJECT-TYPE
    SYNTAX       Unsigned32
              UNIT         millisecond       INTEGER {
                     other(1),        -- not listed here
                     priorityq(2),    -- Priority Queueing
                     wrr(3)           -- Weighed Round Robin
                 }
    MAX-ACCESS   read-create
    STATUS       current
    DESCRIPTION
       "The sampling interval for queue average calculation,
                 in milliseconds.  For queue sampling based on packet
                 enqueueing or dequeueing intervals, scheduling algorithm used by this attribute
                 should contain Scheduler.

        A value of priorityq(2) is used to indicate strict priority
       queueing: only the diffServQPriority attributes of the queues
       feeding this scheduler are used when determining the next packet
       to schedule.

       A value of zero."
              ::= { diffServQMeasureEntry 3 }

          diffServQMeasureAvgWeightExp OBJECT-TYPE
              SYNTAX       Unsigned32
              MAX-ACCESS   read-create
              STATUS       current
                 "The exponent part wrr(3) indicates weighted round-robin scheduling.
       Packets are scheduled from each of weight (in real number format)
                 for queue average calculation.  This is a base 10
                 exponent, with the attribute representing a negative
                 value.  For example, with 8 in queues feeding this attribute meaning
                 10
       scheduler according to all of the power parameters of -8.  An 8 bit value here will be
                 sufficient." the diffServQueue
       entry."
    REFERENCE
        "[MODEL] section 7.1.2"
    ::= { diffServQMeasureEntry 4 diffServSchedulerEntry 3 }

          diffServQMeasureAvgWeightMan

diffServSchedulerNext OBJECT-TYPE
    SYNTAX       Unsigned32       RowPointer
    MAX-ACCESS   read-create
    STATUS       current
                 "The mantissa part
    DESCRIPTION
       "Selects the next data path component, which can be another
       Scheduler or other TC elements. One usage of weight (in real number format) multiple serial
       Schedulers is for queue average calculation.  Always a positive
                 number.  Need 16 bits of accuracy."
              ::= Class Base Queueing (CBQ).

       The value zeroDotZero in this variable indicates no further
       DiffServ treatment is performed on this flow by the current
       interface for this interface direction.  For example, for an
       inbound interface the value zeroDotZero indicates that the packet
       flow has now completed inbound DiffServ treatment and should be
       forwarded on to the appropriate outbound interface."
    DEFVAL       { diffServQMeasureEntry 5 zeroDotZero }

          diffServQMeasureQAverage OBJECT-TYPE
              SYNTAX       Unsigned32
              UNITS        kilo-bits
              MAX-ACCESS   read-only
              STATUS       current
                 "The current queue average in kilo bits."
    ::= { diffServQMeasureEntry 6 diffServSchedulerEntry 4 }

          diffServQMeasureStatus

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

diffServSchedulerUnique OBJECT-TYPE
    SYNTAX       TestAndIncr
    MAX-ACCESS   read-write
    STATUS       current
    DESCRIPTION
       "The diffServSchedulerUnique object yields a unique new value for optical, LAN,
       diffServSchedulerId when read and low speed
          -- interfaces.  The difference is the implementation subsequently set.  This value
       must be tested for uniqueness and can be used by a configuring
       system to obtain a unique value for diffServSchedulerId for
       purposes of row creation in the diffServSchedulerTable."
    ::= { diffServObjects 9 }

-- diffServActionOctetsHCnt, diffServActionPktsHCnt
-- and diffServCountActOctetsHCnt, diffServCountActPktsHCnt. 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 or for configuration.

                 Standard compliance implies that the implementation
                 complies for interfaces for which an interface's octet
                 counter might wrap at most once an hour, which by the
                 IFMIB's convention applies to interfaces under 20 MBPS.
                 It thus applies to any device which might implement a
                 low speed serial line, Ethernet, Token Ring."
       configuration."
    MODULE -- This Module
    MANDATORY-GROUPS {
        diffServMIBClassifierGroup, diffServMIBMeterGroup, diffServMIBSixTupleClfrGroup,
        diffServMIBActionGroup, diffServMIBAlgDropGroup,
        diffServMIBQueueGroup, diffServMIBActionGroup diffServMIBSchedulerGroup }

-- The groups:
--        diffServMIBCounterGroup
-- note that        diffServMIBHCCounterGroup
--        diffServMIBVHCCounterGroup
--
-- are mutually exclusive; at most one of these groups is implemented
-- for a particular interface.  When any of these groups is implemented
-- mandatory for medium and high speed interfaces

                  -- note that diffServMIBVHCCounterGroup is a particular interface, then ifCounterDiscontinuityGroup from
-- mandatory [IFMIB]  must also be implemented for high speed interfaces 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 those network interfaces 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 those network interfaces table objects indexed by ifIndex for
       which the value of the corresponding instance of ifSpeed is
       greater than 650,000,000 bits/second."

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

              OBJECT diffServQueueStatus
              MIN-ACCESS read-only

    GROUP diffServMIBMeterGroup
    DESCRIPTION
                 "Write access
       "This group is not required."
              ::= { diffServMIBCompliances 1 }
          diffServMIBVHCCompliance MODULE-COMPLIANCE
              STATUS current mandatory for devices that implement metering
       functions."

    GROUP diffServMIBTokenBucketMeterGroup
    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 or group is mandatory for configuration.

                 Very High Speed compliance implies devices that the
                 implementation complies for interfaces implement token-bucket
       metering functions."

    GROUP diffServMIBDscpMarkActionGroup
    DESCRIPTION
       "This group is mandatory for which an
                 interface's packet or octet counters might wrap more
                 than once an hour, which by the IFMIB's convention
                 applies to interfaces over 650 MBPS, or OC-12."
              MODULE -- This Module
              MANDATORY-GROUPS {
                  diffServMIBClassifierGroup, diffServMIBMeterGroup,
                  diffServMIBQueueGroup, diffServMIBHCCounterGroup,
                  diffServMIBVHCCounterGroup, diffServMIBActionGroup

                  -- note devices that the implement DSCP-Marking
       functions."

    GROUP diffServMIBStaticGroup
    DESCRIPTION
       "This group is
                  -- mandatory for implementations devices that implement a
                  -- read-write or read-create mode.
              } allow creation of rows
       in any of the writable tables of this MIB."

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    OBJECT diffServQueueStatus diffServMeterFailNext
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is not required."
              ::= { diffServMIBCompliances 2 }
          diffServMIBHCCompliance 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 or for configuration.

                 High Speed compliance implies that the implementation
                 complies for interfaces for which an interface's octet
                 counters might wrap more than once an hour, which by
                 the IFMIB's convention applies to interfaces over 20
                 MBPS, but under 650 MBPS.  It thus applies to devices
                 which implement a 100 MBPS Ethernet, FDDI, E3, DS3, or
                 SONET/SDH interface up to OC-12."
              MODULE -- This Module
              MANDATORY-GROUPS {
                  diffServMIBClassifierGroup, diffServMIBMeterGroup,
                  diffServMIBQueueGroup, diffServMIBHCCounterGroup,
                  diffServMIBActionGroup

                  -- note that diffServMIBVHCCounterGroup is
                  -- mandatory for high speed interfaces

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

              GROUP diffServMIBVHCCounterGroup

    OBJECT diffServMeterSpecific
    MIN-ACCESS read-only
    DESCRIPTION
                 "This group
       "Write access is mandatory for those network interfaces
                 for which the value of the corresponding instance of
                 ifSpeed not required."

    OBJECT diffServMeterStatus
    MIN-ACCESS read-only
    DESCRIPTION
       "Write access is greater than 650,000,000 bits/second." not required."

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    ::= { diffServMIBCompliances 3 1 }

diffServMIBClassifierGroup OBJECT-GROUP
    OBJECTS {
                  diffServAggregateDSCP,
                  diffServClassifierMatchObject,
        diffServClassifierFilter, diffServClassifierNext,
                  diffServClassifierSequence,
        diffServClassifierPrecedence, diffServClassifierStatus
    }
    STATUS current
    DESCRIPTION
       "The Classifier Group defines the MIB Objects that describe a classifier."
       generic classifier element."
    ::= { diffServMIBGroups 1 }

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

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

diffServMIBTokenBucketMeterGroup OBJECT-GROUP
    OBJECTS {
        diffServTBMeterRate, diffServTBMeterBurstSize,
                  diffServTBMeterSucceedNext, diffServTBMeterFailNext,
        diffServTBMeterStatus
    }
    STATUS current
    DESCRIPTION
       "The Token-Bucket Meter Group defines the objects used in
       describing a meter." single-rate token bucket meter element."
    ::= { diffServMIBGroups 2 4 }

diffServMIBActionGroup OBJECT-GROUP
    OBJECTS {
                  diffServActionDropPolicy,
                  diffServActionRandomDrops,
                  diffServActionTailDrops,
                  diffServActionMinThreshold,
                  diffServActionMaxThreshold, diffServActionDSCP,
        diffServActionNext,
                  diffServActionConformingPackets,
                  diffServActionConformingOctets, diffServActionSpecific,
        diffServActionStatus
    }
    STATUS current
    DESCRIPTION
       "The Action Group defines the objects used in describing an action." a
       generic action element."
    ::= { diffServMIBGroups 5 }

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

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

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

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

          diffServMIBHCCounterGroup

diffServMIBAlgDropGroup OBJECT-GROUP
    OBJECTS {
                  diffServActionHCConformingOctets
        diffServAlgDropType, diffServAlgDropNext,
        diffServAlgDropQMeasure, diffServAlgDropQThreshold,
        diffServAlgDropSpecific, diffServAlgDropStatus
    }
    STATUS current
    DESCRIPTION
                 "At 20,000,000 bits per second or greater, the number
                 of octets a given class may count can overflow a 32 bit
                 counter in under an hour.  Therefore, by convention
                 established in the IFMIB,
       "The Algorithmic Drop Group contains the 64 bit counter must be
                 implemented as well." objects that describe
       algorithmic dropper operation and configuration."
    ::= { diffServMIBGroups 4 10 }

          diffServMIBVHCCounterGroup

diffServMIBQueueGroup OBJECT-GROUP
    OBJECTS {
                  diffServActionHCConformingPackets,
                  diffServActionHCRandomDrops,
                  diffServActionHCTailDrops
        diffServQPriority, diffServQNext, diffServQMinRateAbs,
        diffServQMinRateRel, diffServQMaxRateAbs,
        diffServQMaxRateRel, diffServQStatus
    }
    STATUS current
    DESCRIPTION
                 "At 650,000,000 bits per second or greater,
       "The Queue Group contains the number
                 of packets a given class may count can overflow a 32
                 bit counter in under objects that describe an hour.  Therefore, by convention
                 established in the IFMIB, the 64 bit counter must be
                 implemented as well."
       interface's queues."
    ::= { diffServMIBGroups 5 11 }

          diffServMIBQueueGroup

diffServMIBSchedulerGroup OBJECT-GROUP
    OBJECTS {
                  diffServQueueMinimumRate,
                  diffServQueueMaximumRate,
                  diffServQueuePriority, diffServQueueStatus,
                  diffServQueueNextTCB
        diffServSchedulerMethod, diffServSchedulerNext,
        diffServSchedulerStatus
    }
    STATUS current
    DESCRIPTION
       "The Queue Scheduler Group contains the objects that describe an
                 interface's queues." packet
       schedulers on interfaces."
    ::= { diffServMIBGroups 6 12 }

diffServMIBStaticGroup OBJECT-GROUP
    OBJECTS {
        diffServClassifierUnique, diffServTBMeterUnique,
                  diffServQueueUnique, diffServActionUnique diffServSixTupleClfrUnique,
        diffServMeterUnique, diffServActionUnique,
        diffServAlgDropUnique, diffServQUnique, diffServSchedulerUnique
    }
    STATUS current
    DESCRIPTION
       "The Static Group contains scalar objects used in creating unique
       enumerations for classifiers, meters, actions and queues." queues. These
       are required whenever row creation operations on such tables are
       supported."
    ::= { diffServMIBGroups 7 13 }
END

5.  Acknowledgments

This MIB builds on all the work that has gone into the conceptual model
for diffserv routers. It has been developed with the active involvement from a
          number
of sources, many people, but most notably Yoram Bernet, Steve Blake, Brian
Carpenter, Kwok Chan, Dave Durham, Jeremy Greene, Roch Guerin, Scott Hahn, Keith
McCloghrie, Kathleen Nichols, Ping
          Pan, Andrew Smith, Pan and Bert Wijnen.

6.  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 to 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. 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, versions for configuration control,
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 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 control even GET ensure that the SNMP entity
giving access to these
          objects and possibly to even encrypt the values an instance of these
          object when sending them over this MIB, is properly configured to give
access to the network via SNMP.  Not all
          versions of SNMP provide features for such a secure
          environment. objects only to those principals (users) that have
legitimate rights to indeed GET or SET (change/create/delete) them.

7.  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 16, Performance Systems

[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", RFC 1215, Performance Systems International,

[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 Network Services, April
               1999

[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 Virtual Holdings,

[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, First Virtual Holdings,

[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, Inc., BMC Software,

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

[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., Cisco Systems, Inc., April
               1999

[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, Inc., Ericsson,
          [DSCP]

[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

[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."
     Headers", RFC 2474, December 1998.

          [Architecture]

[DSPIB]
     M. Fine, K. McCloghrie, J. Seligson, K. Chan, S. Blake, Hahn, A. Smith,
     "Differentiated Services Policy Information Base", March 2000,
     draft-ietf-diffserv-pib-00.txt

[DSTERMS]
     D. Black, M. Carlson, E. Davies, Z. Wang, W.
               Weiss, "An Architecture Grossman, "New Terminology for Differentiated Service." RFC
               2475, December 1998.

          [AF] J. Heinanen, F. Baker, W. Weiss, J.  Wroclawski, "Assured
               Forwarding PHB Group." RFC 2597, June Diffserv", Internet Draft <draft-
     ietf-diffserv-new-terms-02.txt>, November 1999.

          [EF]

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

          [Model]
               Bernet et al, "A Conceptual Model for Diffserv Routers",
               March 2000, draft-ietf-diffserv-model-02.txt

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

          [DSPIB]
               M. Fine, K. McCloghrie, J. Seligson, K. Chan, S. Hahn, A.
               Smith "Differentiated Services Policy Information Base",
               March 2000, draft-ietf-diffserv-pib-00.txt

[INETADDRESS]
     Daniele, M., Haberman, B., Routhier, S., Schoenwaelder,
               J. J.,
     "Textual Conventions for Internet Network
               Addresses.", February 17, 2000, draft-ops-endpoint-mib-
               07.txt

          [ActQMgmt]
               V. Firoiu, Network Addresses.", Internet
     Draft <draft-ops-endpoint-mib-08.txt>, April 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, "A Conceptual Model for
     Diffserv Routers", Internet Draft <draft-ietf-diffserv-
     model-03.txt>, May 2000.

[POLTERM]
     F. Reichmeyer,  D. Grossman, J. Strassner, M. Borden Condell, "A Study of Active Queue Management Common
     Terminology for Congestion Control", March 2000, In IEEE Infocom
               2000, http://www.ieee-infocom.org/2000/papers/405.pdf Policy Management", Internet Draft <draft-

8.  Authors'  Addresses: 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
     Extreme Networks
     3585 Monroe Street
     Santa Clara, CA 95051
     USA
     andrew@extremenetworks.com

Table of Contents

1 The SNMP Management Framework ...................................    2
2 Structure of this MIB ...........................................    3
2.1 Overview ......................................................    3
2.2 Classifiers ...................................................    4
2.2.1 Classifier Table ............................................    4
2.2.2 IP Six-Tuple Classifier Table ...............................    4
2.3 Meters ........................................................    5
2.3.1 Meter Table .................................................    5
2.3.2 Token-Bucket Meter Table ....................................    5
2.4 Actions .......................................................    6
2.4.1 DSCP Mark Action Table ......................................    6
2.4.2 Count Action Table ..........................................    6
2.4.3 Absolute Drop Action ........................................    7
2.5 Queueing Elements .............................................    7
2.5.1 Algorithmic Dropper Table ...................................    7
2.5.2 Queues and Schedulers .......................................    8
2.5.3 Example of Algorithmic Droppers, Queues and Schedulers ......    9
2.5.4 Example of extending this MIB ...............................   10

2.6 The use of RowPointer .........................................   10
3 Editorial information ...........................................   13
3.1 Open Issues resolved in this draft ............................   13
3.2 Still Open Issues .............................................   15
4 MIB Definition ..................................................   16
5 Acknowledgments .................................................   61
6 Security Considerations .........................................   61
7 References ......................................................   62
8 Authors' Addresses ..............................................   65

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