9324 lines
		
	
	
		
			376 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
			
		
		
	
	
			9324 lines
		
	
	
		
			376 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
-- Mib files packaged on  Tue Mar 17 11:28:59 EDT 2015 for Storage Array Firmware V7.1.5 (R408054)
 | 
						|
 | 
						|
--FROM SNMP-FRAMEWORK-MIB; 
 | 
						|
-- RFC 2571  
 | 
						|
  
 | 
						|
--  These are from draft-ietf-ops-rfc2851-update-00.txt  
 | 
						|
--  You will have to work out the details with your own  
 | 
						|
--  compiler being because they are so new. 
 | 
						|
     
 | 
						|
--equalLogic   OBJECT IDENTIFIER ::= { enterprises 12740 } 
 | 
						|
-- assigned by IANA to EqualLogic.  
 | 
						|
EQLVOLUME-MIB DEFINITIONS  ::= BEGIN   
 | 
						|
IMPORTS  
 | 
						|
    MODULE-IDENTITY, OBJECT-TYPE, Unsigned32, Counter64, Integer32,TimeTicks,  enterprises, IpAddress, Counter32, Counter64, Gauge32
 | 
						|
            FROM SNMPv2-SMI  
 | 
						|
    DateAndTime, RowPointer       
 | 
						|
            FROM SNMPv2-TC
 | 
						|
    TruthValue, RowStatus, DisplayString    
 | 
						|
            FROM SNMPv2-TC
 | 
						|
    InetAddressType, InetAddress
 | 
						|
            FROM INET-ADDRESS-MIB       -- RFC2851
 | 
						|
    equalLogic
 | 
						|
            FROM EQUALLOGIC-SMI
 | 
						|
    eqlGroupId, eqlStorageGroupAdminAccountIndex, UTFString, eqlGroupTaskIndex, eqlLdapLoginAccessName, eqlLdapLoginAccessType
 | 
						|
            FROM EQLGROUP-MIB
 | 
						|
    eqlStoragePoolIndex
 | 
						|
            FROM EQLSTORAGEPOOL-MIB;
 | 
						|
 | 
						|
eqliscsiModule MODULE-IDENTITY      
 | 
						|
	LAST-UPDATED "201503171528Z"
 | 
						|
    ORGANIZATION  "EqualLogic Inc."
 | 
						|
    CONTACT-INFO      
 | 
						|
        "Contact: Customer Support
 | 
						|
         Postal:  Dell Inc
 | 
						|
                  300 Innovative Way, Suite 301, Nashua, NH 03062
 | 
						|
         Tel:     +1 603-579-9762
 | 
						|
         E-mail:  US-NH-CS-TechnicalSupport@dell.com
 | 
						|
         WEB:     www.equallogic.com"
 | 
						|
 | 
						|
    DESCRIPTION          
 | 
						|
        "Storage Array volume information 
 | 
						|
 | 
						|
        Copyright (c) 2004-2011 by Dell, Inc. 
 | 
						|
        
 | 
						|
        All rights reserved.  This software may not be copied, disclosed, 
 | 
						|
        transferred, or used except in accordance with a license granted 
 | 
						|
        by Dell, Inc.  This software embodies proprietary information 
 | 
						|
        and trade secrets of Dell, Inc. 
 | 
						|
        "
 | 
						|
 | 
						|
    -- Revision history, in reverse chronological order
 | 
						|
    REVISION    "200209060000Z"         -- 02-Sep-06
 | 
						|
    DESCRIPTION "Initial revision"    
 | 
						|
    ::= { enterprises equalLogic(12740) 5 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiObjects OBJECT IDENTIFIER ::=  { eqliscsiModule 1 }   
 | 
						|
eqliscsiNotifications OBJECT IDENTIFIER ::= { eqliscsiModule 2 }   
 | 
						|
eqliscsiConformance OBJECT IDENTIFIER ::=  { eqliscsiModule 3 } 
 | 
						|
     
 | 
						|
eqliscsiTarget OBJECT IDENTIFIER ::=  { eqliscsiObjects 7 }  
 | 
						|
 | 
						|
 | 
						|
--***********************************************************************************
 | 
						|
-- Textual conventions
 | 
						|
--
 | 
						|
-- If adding entries here, also update the file mibconv.c !!!
 | 
						|
 | 
						|
ACLAppliesTo ::= TEXTUAL-CONVENTION
 | 
						|
       DISPLAY-HINT       "d"
 | 
						|
       STATUS              current
 | 
						|
       DESCRIPTION        "This textual convention defines the possible states for an
 | 
						|
                           access control group, list, or record as pertains to whether
 | 
						|
                           it applies to the volume, snapshots, or both."
 | 
						|
       SYNTAX              INTEGER  {
 | 
						|
                              volume-only         (1),
 | 
						|
                              snapshot-only       (2),
 | 
						|
                              volume-and-snapshot (3)
 | 
						|
                           }
 | 
						|
 | 
						|
SiteIndex ::= TEXTUAL-CONVENTION
 | 
						|
    DISPLAY-HINT "d"
 | 
						|
    STATUS       current
 | 
						|
    DESCRIPTION
 | 
						|
            "This textual convention defines a greater
 | 
						|
            than zero value used to identify an external group
 | 
						|
            operating autonomously from the local group."
 | 
						|
    SYNTAX       Integer32 (1..2147483647)
 | 
						|
 | 
						|
SiteIndexOrZero ::= TEXTUAL-CONVENTION
 | 
						|
    DISPLAY-HINT "d"
 | 
						|
    STATUS       current
 | 
						|
    DESCRIPTION
 | 
						|
            "This textual convention is an extension of the
 | 
						|
            SiteIndex convention.  The latter defines a greater
 | 
						|
            than zero value used to identify an external group
 | 
						|
            operating autonomously from the local group. This extension permits the
 | 
						|
            additional value of zero.  the value zero is object-specific
 | 
						|
            and must therefore be defined as part of the description of
 | 
						|
            any object which uses this syntax.  Examples of the usage of
 | 
						|
            zero might include situations where the site is unknown or not 
 | 
						|
            relevant"
 | 
						|
    SYNTAX       Integer32 (0..2147483647)
 | 
						|
 | 
						|
 | 
						|
ReplSiteQuotaType ::= TEXTUAL-CONVENTION
 | 
						|
       DISPLAY-HINT       "d"
 | 
						|
       STATUS              current
 | 
						|
       DESCRIPTION        "The format of the adminQuota value:
 | 
						|
                            0 - Unlimited quota,
 | 
						|
                            1 - Size in Megabytes."
 | 
						|
       SYNTAX              INTEGER  {
 | 
						|
                              none(0),
 | 
						|
                              size(1)  
 | 
						|
                            }
 | 
						|
 | 
						|
StatusEnabledDefault ::= TEXTUAL-CONVENTION
 | 
						|
       DISPLAY-HINT       "d"
 | 
						|
       STATUS              current
 | 
						|
       DESCRIPTION        "This textual convention can be used to define a status 
 | 
						|
                           of enabled or disabled. The value 0 is assigned to enabled"
 | 
						|
 | 
						|
       SYNTAX              INTEGER  {
 | 
						|
                            enabled (0),
 | 
						|
                            disabled (1)
 | 
						|
                            }
 | 
						|
 | 
						|
StatusDisabledDefault ::= TEXTUAL-CONVENTION
 | 
						|
       DISPLAY-HINT       "d"
 | 
						|
       STATUS              current
 | 
						|
       DESCRIPTION        "This textual convention can be used to define a status 
 | 
						|
                           of enabled or disabled. The value 0 is assigned to disabled"
 | 
						|
 | 
						|
       SYNTAX              INTEGER  {
 | 
						|
                            disabled (0),
 | 
						|
                            enabled (1)
 | 
						|
                            }
 | 
						|
 | 
						|
StatusAutoDefault ::= TEXTUAL-CONVENTION
 | 
						|
       DISPLAY-HINT       "d"
 | 
						|
       STATUS              current
 | 
						|
       DESCRIPTION        "This textual convention can be used to define a 
 | 
						|
                           status of auto, enabled and disabled. The value 0 
 | 
						|
                           is assigned to auto"
 | 
						|
 | 
						|
       SYNTAX              INTEGER  {
 | 
						|
                            auto (0),
 | 
						|
                            enabled (1),
 | 
						|
                            disabled (2)
 | 
						|
                           }
 | 
						|
 | 
						|
VirtualVolumeType ::= TEXTUAL-CONVENTION
 | 
						|
       DISPLAY-HINT       "d"
 | 
						|
       STATUS              current
 | 
						|
       DESCRIPTION        "This textual convention defines the possible values for virtual volume type"
 | 
						|
       SYNTAX              INTEGER  {
 | 
						|
                              unknown(0),
 | 
						|
                              config-VVol(1),
 | 
						|
                              data-VVol(2),
 | 
						|
                              swap-VVol(3)
 | 
						|
                           }
 | 
						|
 | 
						|
 | 
						|
EQLRowPointer ::= TEXTUAL-CONVENTION
 | 
						|
     STATUS       current
 | 
						|
     DESCRIPTION
 | 
						|
         "Short row pointer that points to a row in one of 
 | 
						|
          the EQL proprietery MIBs. 
 | 
						|
 | 
						|
          For cases when a column 
 | 
						|
          in table X will always refers to a row in table Y a 
 | 
						|
          the generic RowPointer is not space efficient. Storing 
 | 
						|
          the full OID means, the same OID prefix is repeated for 
 | 
						|
          each row in table Y.
 | 
						|
                   
 | 
						|
          This type provides a more compact but context 
 | 
						|
          sensitive way of storing row pointers unlike the 
 | 
						|
          standard RowPointer. Essentially it stores just the
 | 
						|
          instance index of the row it is pointing to, and  
 | 
						|
          not the full table OID. i.e. stores the relative path 
 | 
						|
          and not the absolute path. 
 | 
						|
 | 
						|
          Size is 12 bytes, so it can store a pointer to a 
 | 
						|
          row that has 3 or less parts to its instance index.
 | 
						|
 | 
						|
          Example: If storing pointer to the eqliscsiVolumeTable. 
 | 
						|
          This table has an index with 2 parts 
 | 
						|
          eqliscsiLocalMemberId.eqliscsiVolumeIndex. 
 | 
						|
          byte[4-7]: eqliscsiLocalMemberId
 | 
						|
          byte[8-11]: eqliscsiVolumeIndex"
 | 
						|
 | 
						|
     SYNTAX      OCTET STRING (SIZE (12))
 | 
						|
 | 
						|
EQL2PartRowPointerStr ::= TEXTUAL-CONVENTION
 | 
						|
     STATUS       current
 | 
						|
     DESCRIPTION
 | 
						|
         "Short row pointer that points to a row in one of 
 | 
						|
          the EQL proprietery MIBs. 
 | 
						|
 | 
						|
          For cases when a column 
 | 
						|
          in table X will always refers to a row in table Y a 
 | 
						|
          the generic RowPointer is not space efficient. Storing 
 | 
						|
          the full OID means, the same OID prefix is repeated for 
 | 
						|
          each row in table Y.
 | 
						|
                   
 | 
						|
          This type provides a more compact but context 
 | 
						|
          sensitive way of storing row pointers unlike the 
 | 
						|
          standard RowPointer. Essentially it stores just the
 | 
						|
          two part instance index of the row it is pointing to, and  
 | 
						|
          not the full table OID. i.e. stores the relative path 
 | 
						|
          and not the absolute path. 
 | 
						|
          
 | 
						|
          The base type is a DisplayString using dot notation,
 | 
						|
          .x.y, where x and y are each unsigned integers representing
 | 
						|
          the components of a 2 part complex table index.  
 | 
						|
          Max size of the string is 23 to accommodate the
 | 
						|
          max digits for 2 unsigned integers plus an '.'
 | 
						|
          to separate and prepend the 2 unsigned integers plus 1
 | 
						|
          to accommodate null terminator.
 | 
						|
 | 
						|
          Example: If storing pointer to the eqliscsiVolumeTable. 
 | 
						|
          This table has an index with 2 parts 
 | 
						|
          .eqliscsiLocalMemberId.eqliscsiVolumeIndex"
 | 
						|
 | 
						|
     SYNTAX      DisplayString (SIZE (0..23))
 | 
						|
 | 
						|
 | 
						|
VirtualVolumeSnapshotStatus ::= TEXTUAL-CONVENTION
 | 
						|
       DISPLAY-HINT       "d"
 | 
						|
       STATUS              current
 | 
						|
       DESCRIPTION        "This textual convention defines the possible virtual volume snapshot status"
 | 
						|
       SYNTAX              INTEGER  {
 | 
						|
                              unknown(0),
 | 
						|
                              in-progress(1),
 | 
						|
                              complete(2)                              
 | 
						|
                           }
 | 
						|
 | 
						|
VirtualVolumeCreatedAs ::= TEXTUAL-CONVENTION
 | 
						|
       DISPLAY-HINT       "d"
 | 
						|
       STATUS              current
 | 
						|
       DESCRIPTION        "This textual convention defines the possible virtual volume created as values"
 | 
						|
       SYNTAX              INTEGER  {                      
 | 
						|
                                   stand-alone(1),
 | 
						|
                                   snapshot (2),
 | 
						|
                                   fast-clone (3)                        
 | 
						|
                           }
 | 
						|
 | 
						|
--***********************************************************************************
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Storage Volume Table.
 | 
						|
                     This table contains a list of volumes in a group and their attributes.
 | 
						|
                     TimeoutCreate:60 TimeoutDelete:60"  
 | 
						|
    ::=    { eqliscsiTarget 1 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume info."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeIndex               Unsigned32,   
 | 
						|
        eqliscsiVolumeRowStatus           RowStatus,
 | 
						|
        eqliscsiVolumePsvId               OCTET STRING,
 | 
						|
        eqliscsiVolumeName                UTFString,
 | 
						|
        eqliscsiVolumeSite                OCTET STRING, 
 | 
						|
        eqliscsiVolumeDescription         UTFString,  
 | 
						|
        eqliscsiVolumeAccessType          INTEGER,  
 | 
						|
        eqliscsiVolumeSize                Integer32,  
 | 
						|
        eqliscsiVolumeAdminStatus         INTEGER,  
 | 
						|
        eqliscsiVolumeReservedPercentage  Integer32,       
 | 
						|
        eqliscsiVolumeSnapWarningLevel    Integer32,
 | 
						|
        eqliscsiVolumeSnapDeletionPolicy  INTEGER,
 | 
						|
        eqliscsiVolumeAutoloadBalancing   INTEGER,
 | 
						|
        eqliscsiVolumeTargetAlias         OCTET STRING, 
 | 
						|
        eqliscsiVolumeTargetIscsiName     OCTET STRING,
 | 
						|
        eqliscsiVolumeNodeIndex           Unsigned32,
 | 
						|
        eqliscsiVolumeDataDigests         TruthValue,
 | 
						|
        eqliscsiVolumeHdrDigests          TruthValue,
 | 
						|
        eqliscsiVolumeCloneSrcPsvId       OCTET STRING,
 | 
						|
        eqliscsiVolumeReplService         INTEGER,
 | 
						|
        eqliscsiVolumeMultInitiator       INTEGER,
 | 
						|
        eqliscsiVolumeStoragePoolIndex    Unsigned32,
 | 
						|
        eqliscsiVolumeStoragePoolSourceIndex Unsigned32,
 | 
						|
        eqliscsiVolumeTargetLocalMemberId Unsigned32,
 | 
						|
        eqliscsiVolumeTargetIndex         Unsigned32,
 | 
						|
        eqliscsiVolumeThinProvision       TruthValue,
 | 
						|
        eqliscsiVolumeMinThinReserve      Unsigned32,
 | 
						|
        eqliscsiVolumeThinWarnPercentage  Unsigned32,
 | 
						|
        eqliscsiVolumeThinMaxGrowPercentage Unsigned32,
 | 
						|
        eqliscsiVolumeShrinkAutoAdjust    TruthValue,
 | 
						|
        eqliscsiVolumeReplRollbackSeqNum  Counter64,
 | 
						|
        eqliscsiVolumeThinWarnMode        INTEGER,
 | 
						|
        eqliscsiVolumeFlags               BITS,
 | 
						|
        eqliscsiVolumeTemplate            TruthValue,
 | 
						|
        eqliscsiVolumeThinClone           TruthValue,
 | 
						|
        eqliscsiVolumeThinCloneParentMemberId Unsigned32,
 | 
						|
        eqliscsiVolumeThinCloneParentVolIndex Unsigned32,
 | 
						|
        eqliscsiVolumeThinCloneParentPsvId OCTET STRING,
 | 
						|
        eqliscsiVolumeAdminAccountKey     Unsigned32,
 | 
						|
        eqliscsiVolumeSCSIQErr            INTEGER, 
 | 
						|
        eqliscsiVolumeBorrow              StatusAutoDefault,
 | 
						|
        eqliscsiVolumeSectorSize          INTEGER
 | 
						|
   }
 | 
						|
 | 
						|
eqliscsiVolumeIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      not-accessible     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing a volume."  
 | 
						|
    ::=   { eqliscsiVolumeEntry 1}     
 | 
						|
 | 
						|
eqliscsiVolumeRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiVolumeEntry 2 }  
 | 
						|
 | 
						|
eqliscsiVolumePsvId OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     This field is for internal use only."  
 | 
						|
    ::=  { eqliscsiVolumeEntry 3 }
 | 
						|
 | 
						|
eqliscsiVolumeName OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (1..64))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies a user friendly name for a volume.
 | 
						|
                     The name must be unique within a group.
 | 
						|
                     The name must not contain spaces or special characters.
 | 
						|
                     The name can be up to 64 characters in length. There is no default."
 | 
						|
    ::=  {  eqliscsiVolumeEntry 4 }  
 | 
						|
 | 
						|
eqliscsiVolumeSite OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..64))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the site where the volume resides.
 | 
						|
                     Sites are defined on a per array basis.
 | 
						|
                     Sites are used to define where primary and secondary copies of volume mirror reside.
 | 
						|
                     The default is the default site. This means that the location of the volume is unrestricted."  
 | 
						|
    DEFVAL        {"default"}
 | 
						|
    
 | 
						|
    ::=  {  eqliscsiVolumeEntry 5 } 
 | 
						|
 | 
						|
eqliscsiVolumeDescription OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a descriptive string that provides details about the volume.
 | 
						|
                     The description can be up to 128 characters. There is no default value."  
 | 
						|
    ::=  {  eqliscsiVolumeEntry 6 } 
 | 
						|
          
 | 
						|
eqliscsiVolumeAccessType OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                    read-write(1),
 | 
						|
                    read-only (2)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies access rights for the volume.
 | 
						|
                     The volume can be either read-write or read-only. The default is read-write."  
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=   { eqliscsiVolumeEntry 7}    
 | 
						|
 | 
						|
eqliscsiVolumeSize OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the volume size in MB. There is no default.
 | 
						|
                     Note: Volume size is round to a multiple of 15MB. For thin provisioned volumes
 | 
						|
                     this value represents the advertized size of the volume and 
 | 
						|
                     eqliscsiVolumeMinThinReserve represents the actual reserved size."
 | 
						|
    ::=   { eqliscsiVolumeEntry 8 }   
 | 
						|
 | 
						|
eqliscsiVolumeAdminStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        online(1),
 | 
						|
                        offline(2),
 | 
						|
                        online-lost-cached-blocks(3),
 | 
						|
                        online-control(4),
 | 
						|
                        offline-control(5)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies if the volume is set to online or offline by
 | 
						|
                     the administrator. If a volume is offline, it cannot be accessed
 | 
						|
                     by iscsi initiators.
 | 
						|
 | 
						|
                     When lost blocks that belong to a particular volume are found, the operational
 | 
						|
                     status of the volume is set to not-available-due-to-lost-cached-blocks. 
 | 
						|
                     When the volume is in this state, If the user chooses to ignore the 
 | 
						|
                     lost blocks by setting the volume status to online, the admin status is automatically
 | 
						|
                     set to online-lost-cached-blocks by the subsystem.
 | 
						|
 | 
						|
                     The online-lost-cached-blocks state of admin status conveys the fact that user
 | 
						|
                     acknowledged and acted up on the lost-blocks state of the volume.
 | 
						|
 | 
						|
                     Upon reboot, when the subsystem finds a volume with adminstatus as online-lost-cached-blocks
 | 
						|
                     , it sets the oper status to online instead of not-available-due-to-lost-cached-blocks
 | 
						|
                     as the user already acknowledged the lost-blocks and choose to ignore them."
 | 
						|
 | 
						|
    DEFVAL          { online }
 | 
						|
    ::=   { eqliscsiVolumeEntry 9 } 
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeReservedPercentage OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32     
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies what percentage of the volumesize will be reserved for SnapShots.
 | 
						|
                     This space is reserved in addition to the space reserved for the volume.
 | 
						|
                     The default is 100 percent."  
 | 
						|
    DEFVAL      { 100 } 
 | 
						|
    ::=   { eqliscsiVolumeEntry 10 } 
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeSnapWarningLevel OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..100)
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies when to warn the Administrator that the space reserved for SnapShots.
 | 
						|
                     The warning is sent when the SnapShot Space available drops below the specified percentage.
 | 
						|
                     The default is 20 percent."  
 | 
						|
    DEFVAL          { 20 } 
 | 
						|
    ::=  {  eqliscsiVolumeEntry 11}  
 | 
						|
 | 
						|
eqliscsiVolumeSnapDeletionPolicy OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        make-volume-offline(1),
 | 
						|
                        delete-oldest(2),
 | 
						|
                        stop-snapshots(3)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies what should happen when the space reserved for SnapShots is exhuasted.
 | 
						|
                     The default is delete-oldest SnapShots." 
 | 
						|
    DEFVAL          { delete-oldest }
 | 
						|
    ::=   { eqliscsiVolumeEntry 12 } 
 | 
						|
 | 
						|
eqliscsiVolumeAutoloadBalancing OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        on  (1),
 | 
						|
                        off (2)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies whether or not the volume should be load balanced across multiple
 | 
						|
                     arrays. The default is load balancing is enabled." 
 | 
						|
    DEFVAL          { on }
 | 
						|
    ::=   { eqliscsiVolumeEntry 13 } 
 | 
						|
 | 
						|
eqliscsiVolumeTargetAlias OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..64))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the iSCSI alias used for the volume.
 | 
						|
                     This field defaults to the volume name."  
 | 
						|
    ::=  {  eqliscsiVolumeEntry 14 }  
 | 
						|
 | 
						|
eqliscsiVolumeTargetIscsiName OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..223))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies the iSCSI target name for the volume.
 | 
						|
                     This name is auto-generated, though users can override the name. "  
 | 
						|
    ::=  {  eqliscsiVolumeEntry 15 }  
 | 
						|
 | 
						|
eqliscsiVolumeNodeIndex    OBJECT-TYPE
 | 
						|
   SYNTAX            Unsigned32
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "EQL-SECONDARY-KEY
 | 
						|
                     The arbitrary integer used to uniquely identify this particular
 | 
						|
                     node within the ISCSI mibs. Instances of objects in those MIBS that
 | 
						|
                     are related to this iSCSI target will have this value 
 | 
						|
                     of iscsiNodeIndex"
 | 
						|
   ::=   { eqliscsiVolumeEntry 16 }
 | 
						|
 | 
						|
eqliscsiVolumeHdrDigests   OBJECT-TYPE
 | 
						|
   SYNTAX            TruthValue
 | 
						|
   MAX-ACCESS        read-write
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "An object used by the manager to enable the use of iSCSI header 
 | 
						|
                     digests for this volume. When set to 'true' the iSCSI implementation will 
 | 
						|
                     negotiate the use of header digests with initiators. 
 | 
						|
                     By default this feature will be turned off"
 | 
						|
   DEFVAL            {false}
 | 
						|
   ::=   { eqliscsiVolumeEntry 17 }
 | 
						|
 | 
						|
eqliscsiVolumeDataDigests   OBJECT-TYPE
 | 
						|
   SYNTAX            TruthValue
 | 
						|
   MAX-ACCESS        read-write
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "An object used by the manager to enable the use of iSCSI data
 | 
						|
                     digests for this volume.When set to 'true' the iSCSI implementation will 
 | 
						|
                     negotiate the use of data digests with initiators.
 | 
						|
                     By default this feature will be turned off"
 | 
						|
   DEFVAL            {false}
 | 
						|
   ::=   { eqliscsiVolumeEntry 18 }
 | 
						|
 | 
						|
eqliscsiVolumeCloneSrcPsvId OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "If non-empty, then this volume is a clone of another volume and is waiting
 | 
						|
                     for the data to be copied to it. This field is the PsvId of the source
 | 
						|
                     volume. If value of this field is the empty string then this volume is not a
 | 
						|
                     clone, OR is a clone already populated with the source data."
 | 
						|
    DEFVAL          { "" }
 | 
						|
    ::=  {  eqliscsiVolumeEntry 19 }  
 | 
						|
 | 
						|
eqliscsiVolumeReplService  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        none(1),
 | 
						|
                        replica-site(2),
 | 
						|
                        replicated-primary(3),
 | 
						|
                        replica-control-target(4),
 | 
						|
                        host-control-target(5),
 | 
						|
                        failover(6),
 | 
						|
			pe-control-target(7)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-write      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "Specifies the type of replication services that are provisioned 
 | 
						|
                     on the related volume. A volume may either be a replica, a primary
 | 
						|
                     copy, a replication control target, or nothing at all. 
 | 
						|
                     Regular replicasets on secondary site can be promoted to failover volumes."
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=   {eqliscsiVolumeEntry 20 }
 | 
						|
 | 
						|
eqliscsiVolumeMultInitiator  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        allowed(0),
 | 
						|
                        not-allowed(1)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Specifies if the access from multiple initiators is 
 | 
						|
                     allowed for the volume."
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=   { eqliscsiVolumeEntry 21}
 | 
						|
 | 
						|
eqliscsiVolumeStoragePoolIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifying a storage pool. Thin clones get their pool index from the parent template. "
 | 
						|
    ::=   { eqliscsiVolumeEntry 22}
 | 
						|
 | 
						|
eqliscsiVolumeStoragePoolSourceIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the source storage pool for the volume.
 | 
						|
                     If non-zero, the volume is currently being moved from the
 | 
						|
                     indicated source pool to the target pool (eqliscsiVolumeStoragePoolIndex)."
 | 
						|
    ::=  {  eqliscsiVolumeEntry 23 }
 | 
						|
 | 
						|
eqliscsiVolumeTargetLocalMemberId OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the first part of a unique index for identifing an iSCSI target."
 | 
						|
    ::=   { eqliscsiVolumeEntry 24}
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeTargetIndex OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the second part of a unique index for identifing an iSCSI target."
 | 
						|
    ::=   { eqliscsiVolumeEntry 25}
 | 
						|
 | 
						|
eqliscsiVolumeThinProvision  OBJECT-TYPE
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies if the Volume is enabled for Thin Provisioning."
 | 
						|
    DEFVAL            {false}
 | 
						|
    ::=   { eqliscsiVolumeEntry 26}
 | 
						|
    
 | 
						|
eqliscsiVolumeMinThinReserve  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32(0..100)
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the amount of pool free space that is currently reserved 
 | 
						|
                     for this Thin Provisioned Volume configured as percentage of eqliscsiVolumeSize."
 | 
						|
    ::=   { eqliscsiVolumeEntry 27}
 | 
						|
    
 | 
						|
eqliscsiVolumeThinWarnPercentage  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32(1..100)
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the percentage of Advertised Size for which we send a WARNING 
 | 
						|
                     Message when the Allocated Volume Size reaches it. Default value is eqlGroupDefaultThinWarn."  
 | 
						|
    ::=   { eqliscsiVolumeEntry 28}
 | 
						|
    
 | 
						|
eqliscsiVolumeThinMaxGrowPercentage  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32(1..100)
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the percentage of Advertised Volume Size for which we 
 | 
						|
                     take the volume offline when the Allocated Volume Size reaches it.
 | 
						|
                     Default value is eqlGroupDefaultThinMaxGrow."
 | 
						|
    ::=   { eqliscsiVolumeEntry 29}
 | 
						|
 | 
						|
eqliscsiVolumeShrinkAutoAdjust OBJECT-TYPE
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether snap-reserve should be adjusted automatically when shrinking or growing a volume.
 | 
						|
                     Default value is true. 
 | 
						|
                     Example 1: If volume size is 1500MB, snap-reserve is 100%(1500MB) and snap-reserve used
 | 
						|
                     is 100%(1500MB), when shrinking volume to 750MB, snap-reserve will be automatically adjusted to 200%(1500MB)
 | 
						|
                     so that none of the snapshots will be lost.
 | 
						|
                     Example 2: If volume size is 1500MB, snap-reserve is 200%(3000MB) and snap-reserve used
 | 
						|
                     is 50%(750MB), when shrinking volume to 750MB, snap-reserve will be left at 200%(1500MB) even if 
 | 
						|
                     auto adjust is set to true because the reserve 200%(1500MB) is greater than snap reserve used 750MB."
 | 
						|
    DEFVAL  {true}
 | 
						|
    ::=   { eqliscsiVolumeEntry 30}
 | 
						|
 | 
						|
eqliscsiVolumeReplRollbackSeqNum  OBJECT-TYPE
 | 
						|
    SYNTAX          Counter64
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the seq number of snap from which this volume was rolled back as part of demote or as part of replicaset rollback."
 | 
						|
    ::=   { eqliscsiVolumeEntry 31 }
 | 
						|
 | 
						|
eqliscsiVolumeThinWarnMode OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        warnWithOffline(0),
 | 
						|
                        warnWithIscsi(1),
 | 
						|
                        warnWithOfflineForced(2),
 | 
						|
                        warnWithSoftOnly(3),
 | 
						|
                        warnWithHardOnly(4)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Specifies if the way Thin Provisioning feature will implement the 
 | 
						|
                     Warning Threasholds.  
 | 
						|
                     If 'warnWithOffline', the user will receive event warnings
 | 
						|
                     as they hit the Warning Threshold. When the user hits the MaxGrow
 | 
						|
                     Threshold, the volume will be taken offline.
 | 
						|
                     If 'warnWithIscsi', the user will recieve event warnings
 | 
						|
                     as they hit the Warning Threshold as well as an iSCSI WARNING 
 | 
						|
                     on all writes that would cause a page allocation.  When the user 
 | 
						|
                     hits the MaxGrow Threshold, they will receive a Warning Event and 
 | 
						|
                     an iSCSI WRITE ERROR on all writes that would have cause a page 
 | 
						|
                     allocation.
 | 
						|
                     If 'warnWithOfflineForced' is set, this variable cannot be modified 
 | 
						|
                     by an initiator.  System will have the same behavior as
 | 
						|
                     warnWithOffline.  This value has been deprecated.
 | 
						|
                     If 'warnWithSoftOnly' is set, the user will receive a check condtion
 | 
						|
                     when the volume passes the in-use warn limit.
 | 
						|
                     If 'warnWithHardOnly' is set, the user will receive no check condition
 | 
						|
                     when the volume passes the in-use warn limit, but the volume will reamain
 | 
						|
                     online once it passes the MaxGrow threshold."
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=   { eqliscsiVolumeEntry 32}
 | 
						|
 | 
						|
eqliscsiVolumeFlags OBJECT-TYPE
 | 
						|
    SYNTAX          BITS {
 | 
						|
                    iSNSDiscoverable(0),            -- is the volume iSNS discoverable?
 | 
						|
                    isUnmanaged(1),                 -- is the replicaset or recovery volume manageable
 | 
						|
                    isPoolSyncReplicated(2),        -- is a pool sync replication enabled volume
 | 
						|
                    flag3(3),                       -- unused, available to be used
 | 
						|
                    flag4(4),                       -- unused, available to be used
 | 
						|
                    flag5(5),                       -- unused, available to be used
 | 
						|
                    isNASVolume(6),                 -- is the volume part of a NAS group?
 | 
						|
                    isSyncRepAfoEnabled(7),         -- is an afo enabled volume
 | 
						|
                    flag8(8),
 | 
						|
                    syncReplAllowUnprotectedAccess(9), -- allow failover despite possible unprotected access to the old access pool?
 | 
						|
                    isDeleted(10),                  -- Volume was deleted and is now recoverable
 | 
						|
                    flags11(11),
 | 
						|
                    flag12(12),
 | 
						|
                    flag13(13),
 | 
						|
                    flag14(14),
 | 
						|
                    flag15(15),
 | 
						|
                    flag16(16),
 | 
						|
                    flag17(17),
 | 
						|
                    flag18(18),
 | 
						|
                    flag19(19),
 | 
						|
                    flag20(20),
 | 
						|
                    flag21(21),
 | 
						|
                    flag22(22),
 | 
						|
                    flag23(23),
 | 
						|
                    flag24(24),
 | 
						|
                    flag25(25),
 | 
						|
                    flag26(26),
 | 
						|
                    flag27(27),
 | 
						|
                    flag28(28),
 | 
						|
                    flag29(29),
 | 
						|
                    flag30(30),
 | 
						|
                    flag31(31)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field defines the common place holder for Volume operational flags. " 
 | 
						|
    DEFVAL          { {} }
 | 
						|
    ::= { eqliscsiVolumeEntry 33 }
 | 
						|
 | 
						|
eqliscsiVolumeTemplate  OBJECT-TYPE
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies if the Volume is a Template Volume."
 | 
						|
    DEFVAL          {false}
 | 
						|
    ::=   { eqliscsiVolumeEntry 34 }
 | 
						|
 | 
						|
eqliscsiVolumeThinClone  OBJECT-TYPE
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies if the Volume is a Thin Clone Volume."
 | 
						|
    DEFVAL          {false}
 | 
						|
    ::=   { eqliscsiVolumeEntry 35 }
 | 
						|
    
 | 
						|
eqliscsiVolumeThinCloneParentMemberId OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "If the entry has indicated that this is a Thin Clone Volume, then this
 | 
						|
                     field will specify the Parent Index's MemberId."
 | 
						|
    DEFVAL          {0}
 | 
						|
    ::=   { eqliscsiVolumeEntry 36 }
 | 
						|
 | 
						|
eqliscsiVolumeThinCloneParentVolIndex OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "If the entry has indicated that this is a Thin Clone Volume, then this
 | 
						|
                     field will specify the Parent Index's VolumeIndex."
 | 
						|
    DEFVAL          {0}
 | 
						|
    ::=   { eqliscsiVolumeEntry 37 }
 | 
						|
 | 
						|
eqliscsiVolumeThinCloneParentPsvId OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "If non-empty, then this volume is a Thin Clone of a Template Volume. This field 
 | 
						|
                     is the PsvId of the Template Volume."
 | 
						|
    DEFVAL          { "" }
 | 
						|
    ::=  { eqliscsiVolumeEntry 38 }  
 | 
						|
 | 
						|
eqliscsiVolumeAdminAccountKey OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the unique key for identifying a volume administrator
 | 
						|
                     that owns this volume.  If no account has this value as its 
 | 
						|
                     eqlStorageGroupAdminAccountKey, then the volume is unassigned."
 | 
						|
    DEFVAL          {0}
 | 
						|
    ::=   { eqliscsiVolumeEntry 39 }
 | 
						|
 | 
						|
eqliscsiVolumeSCSIQErr OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        none(0),
 | 
						|
                        zeroZero(1),
 | 
						|
                        zeroOne(2),
 | 
						|
                        oneZero(3),
 | 
						|
                        oneOne(4),
 | 
						|
                        allCommandsAborted(5)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This description is from T10/1799D sbc-3 rev 19.  The following quote is from section 7.4.6 Control mode page.
 | 
						|
 | 
						|
    The queue error management (QERR) field specifies how the device server shall handle other tasks
 | 
						|
when one task is terminated with CHECK CONDITION status (see SAM-3). The task set type (see the TST field
 | 
						|
definition in this subclause) defines which other tasks are affected. If the TST field equals 000b, then all tasks from
 | 
						|
all I_T nexuses are affected. If the TST field equals 001b, then only tasks from the same I_T nexus as the task that
 | 
						|
is terminated with CHECK CONDITION status are affected.
 | 
						|
 | 
						|
Note that the volume's QErr mask is kept in the lower 4 bits and all snapshots QErr mask is kept in the next 4 bits"
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=   { eqliscsiVolumeEntry 40}
 | 
						|
 | 
						|
eqliscsiVolumeBorrow OBJECT-TYPE      
 | 
						|
    SYNTAX          StatusAutoDefault
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies if this Volume is allowed to borrow.
 | 
						|
                     All the volumes including replica sets created in V6.0.0
 | 
						|
                     have this MIB variable set to 'enabled' although V6.0.0
 | 
						|
                     doesn't support delegated space borrowing yet. 
 | 
						|
                    "
 | 
						|
    DEFVAL          {auto}
 | 
						|
    ::=   { eqliscsiVolumeEntry 41 }
 | 
						|
 | 
						|
eqliscsiVolumeSectorSize OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        sector-size-512-bytes(0),
 | 
						|
                        sector-size-4096-bytes(1)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies, in bytes, the sector size of this volume." 
 | 
						|
    DEFVAL          { sector-size-512-bytes }
 | 
						|
    ::=   { eqliscsiVolumeEntry 42 } 
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiSnapshotTable OBJECT-TYPE      
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiSnapshotEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Storage Volume Snap Shot Table
 | 
						|
                     TimeoutCreate:60 TimeoutDelete:60"  
 | 
						|
    ::=  {  eqliscsiTarget 2 }    
 | 
						|
 | 
						|
eqliscsiSnapshotEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiSnapshotEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing snap shot info."
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiSnapshotIndex }    
 | 
						|
::=    { eqliscsiSnapshotTable 1 }
 | 
						|
 | 
						|
    
 | 
						|
EqliscsiSnapshotEntry ::= 
 | 
						|
    SEQUENCE {     
 | 
						|
        eqliscsiSnapshotIndex               Unsigned32,  
 | 
						|
        eqliscsiSnapshotRowStatus           RowStatus,       
 | 
						|
        eqliscsiSnapshotPsvId               OCTET STRING,
 | 
						|
        eqliscsiSnapshotBasePsvId           OCTET STRING, 
 | 
						|
        eqliscsiSnapshotName                OCTET STRING,
 | 
						|
        eqliscsiSnapshotAccessType          INTEGER,  
 | 
						|
        eqliscsiSnapshotSize                Integer32,  
 | 
						|
        eqliscsiSnapshotAdminStatus         INTEGER, 
 | 
						|
        eqliscsiSnapshotTimestamp           Counter32,
 | 
						|
        eqliscsiSnapshotScheduleName        OCTET STRING,
 | 
						|
        eqliscsiSnapshotRollBack            TruthValue,
 | 
						|
        eqliscsiSnapshotTargetAlias         OCTET STRING, 
 | 
						|
        eqliscsiSnapshotTargetIscsiName     OCTET STRING,
 | 
						|
        eqliscsiSnapshotScheduleIndex       Integer32  ,
 | 
						|
        eqliscsiSnapshotDescription         UTFString,
 | 
						|
        eqliscsiSnapshotNodeIndex           Unsigned32,
 | 
						|
        eqliscsiSnapshotReplicated          SiteIndexOrZero,
 | 
						|
        eqliscsiSnapshotType                INTEGER,
 | 
						|
        eqliscsiSnapshotCollectionIndex     INTEGER,
 | 
						|
        eqliscsiSnapshotStoragePoolIndex    Unsigned32,
 | 
						|
        eqliscsiSnapshotTargetLocalMemberId Unsigned32,
 | 
						|
        eqliscsiSnapshotTargetIndex         Unsigned32,
 | 
						|
        eqliscsiSnapshotMultInitiator       INTEGER,
 | 
						|
        eqliscsiSnapshotFlags               BITS,
 | 
						|
        eqliscsiSnapshotCompressionDelay    Unsigned32,
 | 
						|
        eqliscsiSnapshotLifeExpectancy      Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiSnapshotIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index which identifies a volume SnapShot."  
 | 
						|
    ::=  {  eqliscsiSnapshotEntry 1 }
 | 
						|
  
 | 
						|
eqliscsiSnapshotRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The rowstatus...."  
 | 
						|
    ::= {   eqliscsiSnapshotEntry 2 } 
 | 
						|
 | 
						|
eqliscsiSnapshotPsvId  OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     This field contains an internal key for identifing a SnapShot."  
 | 
						|
    ::=  {  eqliscsiSnapshotEntry 3 }  
 | 
						|
 | 
						|
eqliscsiSnapshotBasePsvId OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     This field contains an internal key which identifies the volume the SnapShot is associated with."
 | 
						|
    ::= {   eqliscsiSnapshotEntry 4}  
 | 
						|
 | 
						|
eqliscsiSnapshotName OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the friendly name used to identify a SnapShot.
 | 
						|
                     The name is auto-generated based on the volume name, though it can be
 | 
						|
                     overriden by the administrator."  
 | 
						|
    ::= {   eqliscsiSnapshotEntry 5}  
 | 
						|
 | 
						|
eqliscsiSnapshotAccessType OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        read-write(1),
 | 
						|
                        read-only (2)
 | 
						|
    }        
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the access type for a SnapShot.
 | 
						|
                     The valid access types are read-write and read-only.
 | 
						|
                     The default access type is read-write."  
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::= {  eqliscsiSnapshotEntry 6}  
 | 
						|
 | 
						|
eqliscsiSnapshotSize OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32   
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the amount of space in MB a SnapShot consumes.
 | 
						|
                     Note: Deleting the SnapShot is not guaranteed to return the space specified,
 | 
						|
                     since a single block can be associated with multiple SnapShots. This value is dynamic."
 | 
						|
    ::= {   eqliscsiSnapshotEntry 7 }  
 | 
						|
 | 
						|
eqliscsiSnapshotAdminStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        online(1),
 | 
						|
                        offline(2),
 | 
						|
                        online-lost-cached-blocks(3)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies whether a SnapShot is online or not.
 | 
						|
                     In order for an iSCSI initiator to access a snapshot it must be 
 | 
						|
                     online. The default is offline." 
 | 
						|
    DEFVAL          { offline }
 | 
						|
    ::= {   eqliscsiSnapshotEntry 8 }
 | 
						|
 | 
						|
eqliscsiSnapshotTimestamp OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies the creation time for volume.
 | 
						|
                     Time is represented as the time in seconds since 00:00:00 UTC, 1970-01-01." 
 | 
						|
    ::= {   eqliscsiSnapshotEntry 9 }
 | 
						|
 | 
						|
eqliscsiSnapshotScheduleName OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..64))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the schedule used for SnapShots.
 | 
						|
                     The SnapShot schedule is configured independently and then 
 | 
						|
                     applied to individual volumes.
 | 
						|
                     The default is no schedule is set."  
 | 
						|
    ::= {   eqliscsiSnapshotEntry 10}   
 | 
						|
 | 
						|
eqliscsiSnapshotRollBack OBJECT-TYPE      
 | 
						|
    SYNTAX          TruthValue    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies whether or not to roll a SnapShot back to a specified SnapShot.
 | 
						|
                     This shouldn't be a TruthValue, instead it should be the SnapShot number to roll back to.
 | 
						|
                     There is no default." 
 | 
						|
    DEFVAL          { 2 } -- not an actual number; TBD 
 | 
						|
    ::= {   eqliscsiSnapshotEntry 11 }
 | 
						|
 | 
						|
eqliscsiSnapshotTargetAlias OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies what iSCSI alias will be used to identify the SnapShot.
 | 
						|
                     The alias is autogenerated by default, though it can be overriden."  
 | 
						|
    ::= {   eqliscsiSnapshotEntry 12}   
 | 
						|
 | 
						|
eqliscsiSnapshotTargetIscsiName OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..223))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     This field specifies what iSCSI name will be used to identify the SnapShot.
 | 
						|
                     The name is autogenerated by default, though it can be overriden."  
 | 
						|
    ::= {   eqliscsiSnapshotEntry 13}       
 | 
						|
 | 
						|
eqliscsiSnapshotScheduleIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
        " EQL-SECONDARY-KEY
 | 
						|
          This field specifies the index of the snapshot policy if it is created
 | 
						|
          by a snapshotpolicy, otherwise it will be set to zero. If the policy
 | 
						|
          is deleted after the snapshot is created, this will be reset back to 
 | 
						|
          zero by the subsystem."
 | 
						|
    ::= {   eqliscsiSnapshotEntry 14 }
 | 
						|
   
 | 
						|
eqliscsiSnapshotDescription OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a descriptive string that administrator can add to provide details about the snapshot."
 | 
						|
    DEFVAL          { "" }
 | 
						|
    ::=  {  eqliscsiSnapshotEntry 15 }
 | 
						|
 | 
						|
eqliscsiSnapshotNodeIndex    OBJECT-TYPE
 | 
						|
   SYNTAX            Unsigned32
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "EQL-SECONDARY-KEY
 | 
						|
                     The arbitrary integer used to uniquely identify this particular
 | 
						|
                     node within the ISCSI mibs. Instances of objects in those MIBS that
 | 
						|
                     are related to this iSCSI target will have this value 
 | 
						|
                     of iscsiNodeIndex"
 | 
						|
   ::=   { eqliscsiSnapshotEntry 16 }
 | 
						|
 | 
						|
eqliscsiSnapshotReplicated    OBJECT-TYPE
 | 
						|
   SYNTAX            SiteIndexOrZero
 | 
						|
   MAX-ACCESS        read-create
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "When a row is created with this object set to a non zero value, and
 | 
						|
                     a replication relationship has been configured for the base
 | 
						|
                     volume, the snapshot will be queued to be replicated to the
 | 
						|
                     remote location indicated by the corresponing value 
 | 
						|
                     of site index in the site table 
 | 
						|
 | 
						|
                     The value for this object cannot be changed to zero once the snapshot 
 | 
						|
                     is created."
 | 
						|
   ::=   { eqliscsiSnapshotEntry 17 }
 | 
						|
          
 | 
						|
eqliscsiSnapshotType  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        regular(1),
 | 
						|
                        replica-site(2),
 | 
						|
                        sync-repl-protected(3),
 | 
						|
                        sync-repl-failback(4)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "Specifies the type of snapshot. Snapshot is of type of replica-site when
 | 
						|
                     the parent volume is of type replica-site.
 | 
						|
                    "
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=   {eqliscsiSnapshotEntry 18 }
 | 
						|
 | 
						|
eqliscsiSnapshotCollectionIndex  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The eqliscsiSnapCollectionIndex if this snap is part of a group. 
 | 
						|
                     Otherwise the value will be set to zero."
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=   {eqliscsiSnapshotEntry 19 }
 | 
						|
 | 
						|
eqliscsiSnapshotStoragePoolIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifying a storage pool."
 | 
						|
    ::=   {eqliscsiSnapshotEntry 20 }
 | 
						|
 | 
						|
eqliscsiSnapshotTargetLocalMemberId OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the first part of a unique index for identifing an iSCSI target."
 | 
						|
    ::=   { eqliscsiSnapshotEntry 21}
 | 
						|
 | 
						|
 | 
						|
eqliscsiSnapshotTargetIndex OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the second part of a unique index for identifing an iSCSI target."
 | 
						|
    ::=   { eqliscsiSnapshotEntry 22}
 | 
						|
 | 
						|
eqliscsiSnapshotMultInitiator  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        allowed(0),
 | 
						|
                        not-allowed(1)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Specifies if the access from multiple initiators is 
 | 
						|
                     allowed for the snapshot."
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=   { eqliscsiSnapshotEntry 23}
 | 
						|
 | 
						|
eqliscsiSnapshotFlags OBJECT-TYPE
 | 
						|
    SYNTAX          BITS {
 | 
						|
                    iSNSDiscoverable(0), -- is the snapshot iSNS discoverable?
 | 
						|
                    externalPauseReplication(1), -- Allow us to create replica snapshot in the paused state
 | 
						|
                    compressible(2), -- Allow snapshot to be compressed
 | 
						|
                    flag3(3),
 | 
						|
                    flag4(4),
 | 
						|
                    flag5(5),
 | 
						|
                    flag6(6),
 | 
						|
                    flag7(7),
 | 
						|
                    flag8(8),
 | 
						|
                    flag9(9),
 | 
						|
                    flag10(10),
 | 
						|
                    flag11(11),
 | 
						|
                    flag12(12),
 | 
						|
                    flag13(13),
 | 
						|
                    flag14(14),
 | 
						|
                    flag15(15),
 | 
						|
                    flag16(16),
 | 
						|
                    flag17(17),
 | 
						|
                    flag18(18),
 | 
						|
                    flag19(19),
 | 
						|
                    flag20(20),
 | 
						|
                    flag21(21),
 | 
						|
                    flag22(22),
 | 
						|
                    flag23(23),
 | 
						|
                    flag24(24),
 | 
						|
                    flag25(25),
 | 
						|
                    flag26(26),
 | 
						|
                    flag27(27),
 | 
						|
                    flag28(28),
 | 
						|
                    flag29(29),
 | 
						|
                    flag30(30),
 | 
						|
                    flag31(31)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field defines the common place holder for Snapshot operational flags.  The flags must be of type
 | 
						|
                    enable(1) or disable(0), and the default will always be disable(0)."
 | 
						|
    DEFVAL          { {} }
 | 
						|
    ::= { eqliscsiSnapshotEntry 24 }
 | 
						|
 | 
						|
eqliscsiSnapshotCompressionDelay OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "minutes"
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "The minimum amount of time (minutes) to wait before allowing this snapshot to be compressed."
 | 
						|
    ::=   { eqliscsiSnapshotEntry 25 }
 | 
						|
 | 
						|
eqliscsiSnapshotLifeExpectancy OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "minutes"
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "The amount of time (minutes) this snapshot is estimated to be around."
 | 
						|
    ::=   { eqliscsiSnapshotEntry 26 }
 | 
						|
 | 
						|
---************************************************************      
 | 
						|
eqliscsiVolumeMemberTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeMemberEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Volume Member Table"  
 | 
						|
    ::=   { eqliscsiTarget 3 }     
 | 
						|
 | 
						|
eqliscsiVolumeMemberEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeMemberEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume member info."
 | 
						|
    INDEX           {  eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeMemberIndex }   
 | 
						|
    ::=   { eqliscsiVolumeMemberTable 1 }    
 | 
						|
 | 
						|
EqliscsiVolumeMemberEntry ::= 
 | 
						|
    SEQUENCE {     
 | 
						|
        eqliscsiVolumeMemberIndex           Integer32,  
 | 
						|
        eqliscsiVolumeMemberPssId           Integer32,  
 | 
						|
        eqliscsiVolumeMemberShareOfVolume   Integer32    
 | 
						|
    }
 | 
						|
eqliscsiVolumeMemberIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the index for the Member Volume table."  
 | 
						|
    ::=   { eqliscsiVolumeMemberEntry 1 }  
 | 
						|
 | 
						|
eqliscsiVolumeMemberPssId OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     This field contains the internal id for the Member which hosts a slice of the volume."  
 | 
						|
    ::=  {  eqliscsiVolumeMemberEntry 2 } 
 | 
						|
 | 
						|
eqliscsiVolumeMemberShareOfVolume OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32   
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field contains storage allocated to the volume on the specified member.
 | 
						|
                     The storage is specified in MBs."  
 | 
						|
    ::= {   eqliscsiVolumeMemberEntry 3 }  
 | 
						|
 | 
						|
eqliscsiVolumeInitiatorsTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeInitiatorsEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          deprecated       -- do not use, not supported, never been supported
 | 
						|
    DESCRIPTION     "This table is used to gather information about the iSCSI Initiators connected
 | 
						|
                     to a specified volume."
 | 
						|
    ::=   { eqliscsiTarget 4 }     
 | 
						|
 | 
						|
eqliscsiVolumeInitiatorsEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeInitiatorsEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing Initiator data."
 | 
						|
    INDEX           {  eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeInitiatorsIndex }   
 | 
						|
    ::=   { eqliscsiVolumeInitiatorsTable 1 }    
 | 
						|
 | 
						|
EqliscsiVolumeInitiatorsEntry ::= 
 | 
						|
    SEQUENCE {     
 | 
						|
        eqliscsiVolumeInitiatorsIndex   Integer32,  
 | 
						|
        eqliscsiVolumeInitiatorsName    OCTET STRING        
 | 
						|
    }
 | 
						|
eqliscsiVolumeInitiatorsIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the index to the Volume Initiator table.
 | 
						|
                     The list is created from the iSCSI Initiators connected to a volume."  
 | 
						|
    ::=   { eqliscsiVolumeInitiatorsEntry 1 }
 | 
						|
  
 | 
						|
eqliscsiVolumeInitiatorsName OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..223))    
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the name of the iSCSI Initiator accessing this volume."  
 | 
						|
    ::=   { eqliscsiVolumeInitiatorsEntry 2} 
 | 
						|
 | 
						|
 | 
						|
--***********************************************************************
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyTable OBJECT-TYPE      
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSnapshotPolicyEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Storage SnapSnot Policy Table."  
 | 
						|
    ::=  {  eqliscsiTarget 5 }    
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSnapshotPolicyEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing snapshot scheduling policy 
 | 
						|
                     information.The policy determines when to create 
 | 
						|
                     snapshot(s) of a volume."
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeSnapshotPolicyIndex }    
 | 
						|
::=    { eqliscsiVolumeSnapshotPolicyTable 1 }
 | 
						|
 | 
						|
    
 | 
						|
EqliscsiVolumeSnapshotPolicyEntry ::= 
 | 
						|
    SEQUENCE {     
 | 
						|
        eqliscsiVolumeSnapshotPolicyIndex               Integer32,  
 | 
						|
        eqliscsiVolumeSnapshotPolicyRowStatus           RowStatus,
 | 
						|
        eqliscsiVolumeSnapshotPolicyName                OCTET STRING,
 | 
						|
        eqliscsiVolumeSnapshotPolicyAccessType          INTEGER, 
 | 
						|
        eqliscsiVolumeSnapshotPolicyStatus              INTEGER, 
 | 
						|
        eqliscsiVolumeSnapshotPolicyMaxKeep             Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyType                INTEGER,
 | 
						|
        eqliscsiVolumeSnapshotPolicyRepeatFactor        Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyStartTime           Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyEndTime             Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyTimeFrequency       Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyStartDate           Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyEndDate             Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyWeekMask            Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyMonthMask           Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyNextCreate          Counter32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyOccurence           Integer32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyReplication         SiteIndexOrZero,
 | 
						|
        eqliscsiVolumeSnapshotPolicyAdminStatus         INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "This value uniquely identifies the snapshot policies for a volume."
 | 
						|
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "This value is used to manage the conceptual row."
 | 
						|
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 2 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyName  OBJECT-TYPE   
 | 
						|
    SYNTAX          OCTET STRING (SIZE (1..64))    
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "This value specifies user friendly name for the policy. 
 | 
						|
           It is unique within the context of a volume. Spaces are not allowed."
 | 
						|
                     
 | 
						|
    ::=   { eqliscsiVolumeSnapshotPolicyEntry 3}
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyAccessType  OBJECT-TYPE   
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                      read-write (1),
 | 
						|
                      read-only  (2)
 | 
						|
    }   
 | 
						|
    MAX-ACCESS      read-create       
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "Snapshots created using this policy will have accesstype same as the
 | 
						|
           value of this object." 
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 4 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyStatus  OBJECT-TYPE   
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                      online  (1),
 | 
						|
                      offline (2) 
 | 
						|
    }   
 | 
						|
    MAX-ACCESS      read-create       
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "Snapshots created using this policy will have status same as the
 | 
						|
           value of this object."
 | 
						|
 | 
						|
    DEFVAL          { offline }
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 5 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyMaxKeep  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (1..2147483647)
 | 
						|
    UNITS           "snapshots"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this object determines the maximum no of snapshots
 | 
						|
           created by this policy that can exist at a given time. When number
 | 
						|
           of snapshots created by this policy reaches this value, for creating
 | 
						|
           a new snapshot oldest snapshot created using this policy will be 
 | 
						|
           deleted.
 | 
						|
           In a set operation, if the new value of this object is less than
 | 
						|
           the old value, required number of oldest snapshots created by this
 | 
						|
           policy will be deleted. 
 | 
						|
          "
 | 
						|
    DEFVAL          { 10 }
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 6 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyType  OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                      once    (1),
 | 
						|
                      daily   (2),
 | 
						|
                      weekly  (3),
 | 
						|
                      monthly (4),
 | 
						|
                      hourly  (5)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this object determines the basic type of this policy.
 | 
						|
           Except when set to once, the effective repetition period of the 
 | 
						|
           policy is determined using the value of this object along with
 | 
						|
           the value of eqliscsiVolumeSnapshotPolicyRepeatFactor. 
 | 
						|
           (See description of eqliscsiVolumeSnapshotPolicyRepeatFactor 
 | 
						|
            for more information.)
 | 
						|
          "
 | 
						|
 | 
						|
    DEFVAL          { daily }
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 7 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyRepeatFactor  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (1..2147483647)
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "The value of this object along with eqliscsiVolumeSnapshotPolicyType
 | 
						|
           determines the effective repetition interval for this policy.
 | 
						|
           The valid values are
 | 
						|
 | 
						|
              PolicyType            RepeatFactor  
 | 
						|
                 once                    1
 | 
						|
                 hourly                  1
 | 
						|
                 daily                  1-2147483647
 | 
						|
                 weekly                 1-2147483647
 | 
						|
                 monthly                1-2147483647
 | 
						|
 | 
						|
           If the policy type is daily and the value of this object is 2,
 | 
						|
           snapshots will be taken once in every 2 days.
 | 
						|
          "
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 8 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyStartTime  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..1439)
 | 
						|
    UNITS           "minutes"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " 
 | 
						|
            The value of this object represents the time to start creating
 | 
						|
            snapshot(s) within a day expressed as number of minutes 
 | 
						|
            from 12:00AM. The maximum value for this column is 24*60-1 which 
 | 
						|
            represents 11:59PM.
 | 
						|
          "
 | 
						|
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 9 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyEndTime  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..1439)
 | 
						|
    UNITS           "minutes"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION      
 | 
						|
          " 
 | 
						|
            The value of this object represents the time to stop creating
 | 
						|
            snapshot(s) within a day expressed as number of minutes 
 | 
						|
            from 12:00AM. The maximum value for this column is 24*60-1 which 
 | 
						|
            represents 11:59PM. 
 | 
						|
 
 | 
						|
            If eqliscsiVolumeSnapshotPolicyType is once, the value of
 | 
						|
            this column doesn't have any significance. 
 | 
						|
 | 
						|
            If the value of this column is greater than start time, it 
 | 
						|
            represents end-time on the same day as start time. If the value 
 | 
						|
            is less than or equal to start time, it represents end-time on the
 | 
						|
            next day of start time.
 | 
						|
            This value doesnt have significance when frequency is set to zero.
 | 
						|
            Endtime is exclusive when calculating no of snapshots.
 | 
						|
 | 
						|
            Example:
 | 
						|
                     StartTime      EndTime    Frequency    NoofSnapshots
 | 
						|
                       1320(10pm)   1380(11pm)    30mins        2
 | 
						|
                       1320(10pm)   240(4am)      60mins        6
 | 
						|
                       1320(10pm)   1320(10pm)    60mins        24
 | 
						|
                       1320(10pm)   1319(9:59pm)  60mins        24
 | 
						|
                       1320(10pm)     -            0mins         1
 | 
						|
          "
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 10 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyTimeFrequency  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..1439)
 | 
						|
    UNITS           "minutes"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "The value of this object determines how frequent snapshots must be 
 | 
						|
           taken between start time and end time. This value doesn't have 
 | 
						|
           significance when policy type is set to once. For other policytypes,
 | 
						|
           the value of end time is exclusive. 
 | 
						|
           For example if starttime is 180 (3:00AM) and endtime is 
 | 
						|
           240(4:00AM), when frequency is set to 30, snapshots will be 
 | 
						|
           created at 3:00AM, 3:30AM.
 | 
						|
           If the value is zero, it represents invalid frequency and
 | 
						|
           in such case, end time doesnt have significance.
 | 
						|
          "
 | 
						|
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 11 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyStartDate  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..2147483647)
 | 
						|
    UNITS           "days"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " The value of this object determines the date from which the policy
 | 
						|
            will be active. By default, this is the policy creation date.
 | 
						|
            The value is expressed as number of days since epoch.
 | 
						|
          "  
 | 
						|
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 12 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyEndDate  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..2147483647)
 | 
						|
    UNITS           "days"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " The value of this object determines the date after which the policy
 | 
						|
            will be inactive.It doesnt have significance when policy type
 | 
						|
            is once. Default value is the mamixum value allowed. When set to maximum
 | 
						|
            value, the policy will be active until it gets deleted.
 | 
						|
            The value is expressed as number of days since epoch.
 | 
						|
          "  
 | 
						|
    DEFVAL          { 2147483647 }
 | 
						|
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 13 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyWeekMask  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " The value of this column is significant only if policytype is
 | 
						|
            set to weekly or monthly.  When the value is 0x7fffffff, it 
 | 
						|
            represents a special meaning to the value of occurence. See
 | 
						|
            the description for occurence below.
 | 
						|
            The LSB to LSB+6 bits of the mask are significant.
 | 
						|
            Each bit represents a day in the week with LSB being Mon and LSB+6
 | 
						|
            being Sun.
 | 
						|
            If mask is 0x00000041 - snapshots will be created on Monday and 
 | 
						|
            Sunday. If mask is 0x0000007f - snapshots will be created on all
 | 
						|
            weekdays which is effectively a daily policy. If mask is 0x0000001f,
 | 
						|
            it represents week days.If mask is 0x00000060, it represents
 | 
						|
            weekend days.
 | 
						|
          "
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 14 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyMonthMask  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " The value of this column is currently not being used."
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 15 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyNextCreate  OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32 
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           EQL-SECONDARY-KEY 
 | 
						|
           The value of this column represents number of seconds since epoch
 | 
						|
           at which the next snapshot by this policy is going to be created.
 | 
						|
          "
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 16 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyOccurence  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this column is significant only if the policy type is
 | 
						|
           set to monthly.
 | 
						|
 | 
						|
           If weekmask is set to 0x7fffffff, the value of this column represents
 | 
						|
           the occurence of a day with in a month. Example:If the value of this 
 | 
						|
           column is 5, it represents 5th day of the month. When the week mask
 | 
						|
           is set to a value other than 0x7fffffff, the value of this column
 | 
						|
           defines the occurence of a day as defined by weekmask. Example: When
 | 
						|
            weekmask is set to 0x00000001 (Monday) and value of this column
 | 
						|
           represents the following.
 | 
						|
 
 | 
						|
                        Value            Meaning
 | 
						|
 | 
						|
                          0x1               First monday of the month
 | 
						|
                          0x2               Second monday of the month
 | 
						|
                          0x3               Third monday of the month
 | 
						|
                          0x4               Fourth monday of the month
 | 
						|
                          0x7fffffff        Last monday of the month
 | 
						|
          "
 | 
						|
 | 
						|
    DEFVAL  {0}
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyEntry 17 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyReplication    OBJECT-TYPE
 | 
						|
   SYNTAX            SiteIndexOrZero
 | 
						|
   MAX-ACCESS        read-create
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "When a row is created with this object set to a non-zero value, and
 | 
						|
                     a replication relationship has been configured for the base
 | 
						|
                     volume, the snapshots created will be queued to be replicated to the
 | 
						|
                     remote location as defined by the corresponding entry in the site table.
 | 
						|
                     The value for this object cannot be changed once the schedule
 | 
						|
                     is created."
 | 
						|
   ::=   { eqliscsiVolumeSnapshotPolicyEntry 18 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyAdminStatus    OBJECT-TYPE
 | 
						|
   SYNTAX            INTEGER {
 | 
						|
                        enable(0),
 | 
						|
                        disable(1)
 | 
						|
   }
 | 
						|
   MAX-ACCESS        read-create
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "When disabled, the schedule will stop creating snapshots until re-enabled."
 | 
						|
   DEFVAL            {enable}
 | 
						|
   ::=   { eqliscsiVolumeSnapshotPolicyEntry 19 }
 | 
						|
 | 
						|
 | 
						|
--*************************************************************************
 | 
						|
eqliscsiVolumeACLTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeACLEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent-ReplicateOnCreate volume access table. 
 | 
						|
                     This table contains a collection of volume access records. 
 | 
						|
                     One table entry per access record. It is indexed by group id, volume,
 | 
						|
                     index and volume access record index. 
 | 
						|
                     The number of entries equal to the number of volume access records specified by the user."  
 | 
						|
    ::=   { eqliscsiTarget 6 }     
 | 
						|
 | 
						|
eqliscsiVolumeACLEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeACLEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume access parameters to this target."        
 | 
						|
    INDEX           {  eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeACLIndex }   
 | 
						|
    ::=   { eqliscsiVolumeACLTable 1 }    
 | 
						|
 | 
						|
EqliscsiVolumeACLEntry ::= 
 | 
						|
    SEQUENCE {     
 | 
						|
        eqliscsiVolumeACLIndex                          Integer32,  
 | 
						|
        eqliscsiVolumeACLInitiatorName                  UTFString,
 | 
						|
        eqliscsiVolumeACLInitiatorIpAddress         IpAddress,
 | 
						|
        eqliscsiVolumeACLInitiatorAuthenticationMethod  INTEGER,
 | 
						|
        eqliscsiVolumeACLInitiatorUserName              UTFString,
 | 
						|
        eqliscsiVolumeACLInitiatorUserPassword          OCTET STRING,
 | 
						|
        eqliscsiVolumeACLTargetType                     ACLAppliesTo,
 | 
						|
        eqliscsiVolumeACLRowStatus                      RowStatus,       
 | 
						|
        eqliscsiVolumeACLInitiatorUserName2             UTFString,
 | 
						|
        eqliscsiVolumeACLAuthType                       INTEGER,
 | 
						|
        eqliscsiVolumeACLInitiatorIpWildcard        IpAddress,
 | 
						|
        eqliscsiVolumeACLInitiatorInetAddressType         InetAddressType,
 | 
						|
        eqliscsiVolumeACLInitiatorInetAddress             InetAddress,
 | 
						|
        eqliscsiVolumeACLInitiatorInetWildcardType        InetAddressType,
 | 
						|
        eqliscsiVolumeACLInitiatorInetWildcard            InetAddress
 | 
						|
    }
 | 
						|
eqliscsiVolumeACLIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The index value that uniquely identifies the volume access record."
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 1 }
 | 
						|
  
 | 
						|
eqliscsiVolumeACLInitiatorName OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (0..223))
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current    
 | 
						|
    DESCRIPTION     "The name of iscsi initiator permitted to access the volume.
 | 
						|
                     If the name is an empty string or * then any initiator is allowed to access." 
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 2}
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorIpAddress OBJECT-TYPE      
 | 
						|
    SYNTAX          IpAddress    
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is deprecated and will be unsupported in the next release."
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 3}
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorAuthenticationMethod OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER  {
 | 
						|
                        chap5       (1),
 | 
						|
                        chap-local  (2),
 | 
						|
                        srp-local   (3),
 | 
						|
                        none        (4)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The authentication method to be used for initiator authentication."  
 | 
						|
    DEFVAL          { none }
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 4}
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorUserName OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (0..128))
 | 
						|
--  SYNTAX          OCTET STRING (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          deprecated
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     The user name to be used for initiator authentication if the authentication method
 | 
						|
                     is CHAP5 local or SRP local."  
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 5}
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorUserPassword OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The user name to be used for initiator authentication if the authentication method
 | 
						|
                     is CHAP5 local or SRP local"  
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 6}
 | 
						|
 | 
						|
 | 
						|
 | 
						|
 eqliscsiVolumeACLTargetType OBJECT-TYPE      
 | 
						|
    SYNTAX          ACLAppliesTo     
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The target type to be authenticated."
 | 
						|
    DEFVAL          { volume-and-snapshot }
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 7}
 | 
						|
 | 
						|
eqliscsiVolumeACLRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The volume acl row status."  
 | 
						|
    ::=  {  eqliscsiVolumeACLEntry  8 }
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorUserName2 OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (0..255))
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     The 256 byte character name user name to be used for initiator 
 | 
						|
                     authentication if the authentication method
 | 
						|
                     is CHAP5 local or SRP local. This field supercedes the deprecated 
 | 
						|
                     128 byte field that performed the same function. "  
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 9}
 | 
						|
 | 
						|
eqliscsiVolumeACLAuthType OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER  {
 | 
						|
                        not-set      (0),
 | 
						|
                        none         (1),
 | 
						|
                        eql-psg-chap (2),
 | 
						|
                        radius       (3),
 | 
						|
                        ms-vds       (4),
 | 
						|
                        mpio         (5)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The authentication type used.  Currently it is set only by
 | 
						|
                     vds and should be left alone by the PSA firmware and non-vds
 | 
						|
                     PSA configuration tools."
 | 
						|
    DEFVAL          { not-set }
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 10 }
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorIpWildcard OBJECT-TYPE      
 | 
						|
    SYNTAX          IpAddress    
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is deprecated and will be unsupported in the next release."
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 11}
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorInetAddressType OBJECT-TYPE      
 | 
						|
    SYNTAX          InetAddressType
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The ip address of the iscsi initiator permitted to access the volume
 | 
						|
                     in the form of x.x.x.number.
 | 
						|
                     If the number is zero then any ip address with the value from  x.x.x.1 to x.x.x.255
 | 
						|
                     is permitted to access the volume.
 | 
						|
                     If this variable is not set then any ip address will be permitted to access the volume."  
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 12}
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorInetAddress OBJECT-TYPE      
 | 
						|
    SYNTAX          InetAddress
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The ip address of the iscsi initiator permitted to access the volume
 | 
						|
                     in the form of x.x.x.number.
 | 
						|
                     If the number is zero then any ip address with the value from  x.x.x.1 to x.x.x.255
 | 
						|
                     is permitted to access the volume.
 | 
						|
                     If this variable is not set then any ip address will be permitted to access the volume."  
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 13}
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorInetWildcardType OBJECT-TYPE      
 | 
						|
    SYNTAX          InetAddressType
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The wildcard mask defines which portion of eqliscsiVolumeACLInitiatorInetAddress that
 | 
						|
                     does not have to match for the initiator to be permitted access to the volume.
 | 
						|
                     The wildcard mask is expressed in the form x.x.x.x, where x is 255 or 0. 
 | 
						|
 | 
						|
                     When x is 255, then that portion of the initiator's ip address does have to match.  
 | 
						|
                     When x is 0, then that portion of the initiator's ip address does not have to match 
 | 
						|
                     the corresponding portion of eqliscsiVolumeACLInitiatorInetAddress.
 | 
						|
 | 
						|
                     By default, the value of this variable is 255.255.255.255, which means the initiator's ip
 | 
						|
                     address must match exactly unless this variable is specified."
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 14}
 | 
						|
 | 
						|
eqliscsiVolumeACLInitiatorInetWildcard OBJECT-TYPE      
 | 
						|
    SYNTAX          InetAddress
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The wildcard mask defines which portion of eqliscsiVolumeACLInitiatorInetAddress that
 | 
						|
                     does not have to match for the initiator to be permitted access to the volume.
 | 
						|
                     The wildcard mask is expressed in the form x.x.x.x, where x is 255 or 0. 
 | 
						|
 | 
						|
                     When x is 255, then that portion of the initiator's ip address does have to match.  
 | 
						|
                     When x is 0, then that portion of the initiator's ip address does not have to match 
 | 
						|
                     the corresponding portion of eqliscsiVolumeACLInitiatorInetAddress.
 | 
						|
 | 
						|
                     By default, the value of this variable is 255.255.255.255, which means the initiator's ip
 | 
						|
                     address must match exactly unless this variable is specified."
 | 
						|
    ::=   { eqliscsiVolumeACLEntry 15}
 | 
						|
 | 
						|
 | 
						|
--*************************************************************************
 | 
						|
 | 
						|
eqliscsiVolumeStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage Volume Table.
 | 
						|
                     This table contains a list of volumes in a group and their stats." 
 | 
						|
    ::=    { eqliscsiTarget 7 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume stats."
 | 
						|
    AUGMENTS        { eqliscsiVolumeEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeStatusEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeStatusPsvId               OCTET STRING,
 | 
						|
        eqliscsiVolumeStatusReservedSpace       Integer32,      
 | 
						|
        eqliscsiVolumeStatusReservedSpaceAvail  Integer32,
 | 
						|
        eqliscsiVolumeStatusActualMemberCount   Integer32,
 | 
						|
        eqliscsiVolumeStatusNumSnapshots        Integer32,
 | 
						|
        eqliscsiVolumeStatusCreationTime        DateAndTime,
 | 
						|
        eqliscsiVolumeStatusAvailable           INTEGER,
 | 
						|
        eqliscsiVolumeStatusOperStatus          INTEGER,
 | 
						|
        eqliscsiVolumeStatusConnections         Integer32,
 | 
						|
        eqliscsiVolumeStatusLostRaidBlocksAction  INTEGER,
 | 
						|
        eqliscsiVolumeStatusNumReplicas           Unsigned32,
 | 
						|
        eqliscsiVolumeStatusReplReserveSpace      Unsigned32,
 | 
						|
        eqliscsiVolumeStatusAllocatedSpace        Unsigned32,
 | 
						|
        eqliscsiVolumeStatusReplResvInUse         Unsigned32,
 | 
						|
        eqliscsiVolumeStatusReplTxData            Unsigned32,
 | 
						|
        eqliscsiVolumeStatusNumOnlineSnaps        Unsigned32,
 | 
						|
        eqliscsiVolumeStatusPagesSharedWithParent Unsigned32,
 | 
						|
        eqliscsiVolumeStatusExternalConnections   Integer32,
 | 
						|
        eqliscsiVolumeStatusSpaceBorrowing        Integer32,     
 | 
						|
        eqliscsiVolumeStatusBorrow                INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeStatusPsvId OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "
 | 
						|
                     This field is for internal use only."  
 | 
						|
    ::=  { eqliscsiVolumeStatusEntry 1 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeStatusReservedSpace OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies how many MB of space is reserved for
 | 
						|
                     snapshots of this volume.
 | 
						|
                     This is a dynamic value, it is not Administrator setable."
 | 
						|
    ::=   { eqliscsiVolumeStatusEntry 2}  
 | 
						|
 | 
						|
eqliscsiVolumeStatusReservedSpaceAvail OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies how many MB of reserved space that is unused
 | 
						|
                     by the snapshots."
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=   { eqliscsiVolumeStatusEntry 3 } 
 | 
						|
 | 
						|
eqliscsiVolumeStatusActualMemberCount OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the number of members this
 | 
						|
                     volume is spread across. It must be equal to number 
 | 
						|
                     of rows in VolumeMemberTable for this volume."
 | 
						|
    ::=   { eqliscsiVolumeStatusEntry 4 } 
 | 
						|
 | 
						|
eqliscsiVolumeStatusNumSnapshots  OBJECT-TYPE
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Indicates the number of snapshots that the system is 
 | 
						|
                     maintaining on the specified volume"
 | 
						|
    ::=   { eqliscsiVolumeStatusEntry 5 } 
 | 
						|
 | 
						|
eqliscsiVolumeStatusCreationTime  OBJECT-TYPE
 | 
						|
    SYNTAX          DateAndTime
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Indicates the local system time when the specified 
 | 
						|
               volume was created"
 | 
						|
    ::=   { eqliscsiVolumeStatusEntry 6 } 
 | 
						|
 | 
						|
eqliscsiVolumeStatusAvailable  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                        available(1),
 | 
						|
                        membersMissing(2)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Indicates the local system time when the specified 
 | 
						|
                     volume was created"
 | 
						|
    ::=   { eqliscsiVolumeStatusEntry 7 } 
 | 
						|
 | 
						|
eqliscsiVolumeStatusOperStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        available(1),
 | 
						|
                        not-available(2),
 | 
						|
                        not-available-due-to-snap-reserve-met(3),
 | 
						|
                        not-available-due-to-members-offline(4),
 | 
						|
                        not-available-due-to-lost-cached-blocks(5),
 | 
						|
                        not-available-due-to-thin-max-growth-met(6),
 | 
						|
                        not-available-due-to-nospace-for-auto-grow(7),
 | 
						|
                        not-available-due-to-missing-pages(8),
 | 
						|
                        not-available-due-to-syncrep(9),
 | 
						|
                        available-no-new-connections(10),
 | 
						|
                        not-available-due-to-internal-error(11)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the current operational status of the 
 | 
						|
                     volume."
 | 
						|
    ::= {   eqliscsiVolumeStatusEntry 8 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusConnections OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
            "
 | 
						|
             The value of this object represents number of active iscsi 
 | 
						|
             connections to this volume. It MUST match with the number of rows 
 | 
						|
             for this particular iscsiNode in iscsiConnectionAttributesTable.
 | 
						|
            "
 | 
						|
    ::= {   eqliscsiVolumeStatusEntry 9 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusLostRaidBlocksAction  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        mark-valid  (1),
 | 
						|
                        zero-out    (2)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-write      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies what action administrator wants to take on lost raid blocks."
 | 
						|
    ::=   {eqliscsiVolumeStatusEntry 10 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusNumReplicas  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "
 | 
						|
                     The value of this object represents the total number of replicas present
 | 
						|
                     for this volume across all replica sites.
 | 
						|
                     The value will match with the sum of values of eqliscsiVolumeReplNumReplicas
 | 
						|
                     that correspond to this volume."
 | 
						|
    DEFVAL           { 0 }
 | 
						|
    ::=   {eqliscsiVolumeStatusEntry 11 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusReplReserveSpace  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "
 | 
						|
                     The value of this object represents space reserved for this volume for
 | 
						|
                     replication purposes.
 | 
						|
                    "
 | 
						|
    DEFVAL           { 0 }
 | 
						|
    ::=   {eqliscsiVolumeStatusEntry 12 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusAllocatedSpace  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "
 | 
						|
                     The value of this object represents the actual materialized pages for this volume. 
 | 
						|
                    "
 | 
						|
    ::=   {eqliscsiVolumeStatusEntry 13 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusReplResvInUse   OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   UNITS           "MB"
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "This field represents the amount of local replication reserve in use."
 | 
						|
 | 
						|
    ::=   {eqliscsiVolumeStatusEntry 14 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusReplTxData   OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   UNITS           "MB"
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "This field represents the amount of data that will be transferred during next replication."
 | 
						|
 | 
						|
    ::=   {eqliscsiVolumeStatusEntry 15 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusNumOnlineSnaps  OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "This field represents the number of online snapshots on this volume."
 | 
						|
    ::=   {eqliscsiVolumeStatusEntry 16 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusPagesSharedWithParent  OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "This field represents the number of pages the volume shares with its parent. Is NA for a non-thin clone volume"
 | 
						|
    ::=   {eqliscsiVolumeStatusEntry 17 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusExternalConnections OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
            "
 | 
						|
             The value of this object represents number of active iscsi 
 | 
						|
             connections to this volume, not counting any extended copy 
 | 
						|
             sessions.
 | 
						|
            "
 | 
						|
    ::= {   eqliscsiVolumeStatusEntry 18 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusSpaceBorrowing OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
            "This field specifies how many MB of space that this volume is borrowing."
 | 
						|
    ::= { eqliscsiVolumeStatusEntry 19 }
 | 
						|
 | 
						|
eqliscsiVolumeStatusBorrow OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        unavailable(0),
 | 
						|
                        enabled(1),
 | 
						|
                        disabled(2)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies operational status of borrowing."
 | 
						|
    ::= { eqliscsiVolumeStatusEntry 20 }
 | 
						|
 | 
						|
--*************************************************************************
 | 
						|
 | 
						|
eqliscsiSnapshotStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiSnapshotStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage Snapshot Table.
 | 
						|
                     This table contains a list of volumes in a group and their stats." 
 | 
						|
    ::=    { eqliscsiTarget 8 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiSnapshotStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiSnapshotStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume stats."
 | 
						|
    AUGMENTS        { eqliscsiSnapshotEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiSnapshotStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiSnapshotStatusEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiSnapshotStatusOperStatus          INTEGER,
 | 
						|
        eqliscsiSnapshotStatusConnections         Integer32,
 | 
						|
        eqliscsiSnapshotStatusLostRaidBlocksAction  INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiSnapshotStatusOperStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        available(1),
 | 
						|
                        not-available(2),
 | 
						|
                        not-available-due-to-snap-reserve-met(3),
 | 
						|
                        not-available-due-to-members-offline(4),
 | 
						|
                        not-available-due-to-lost-cached-blocks(5),
 | 
						|
                        not-available-due-to-thin-max-growth-met(6),
 | 
						|
                        not-available-due-to-nospace-for-auto-grow(7),
 | 
						|
                        not-available-due-to-missing-pages(8)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the current operational status of the 
 | 
						|
                     snapshot."
 | 
						|
    ::= {   eqliscsiSnapshotStatusEntry 1 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSnapshotStatusConnections OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
         "
 | 
						|
         The value of this object represents number of active iscsi connections
 | 
						|
         to this snapshot. It MUST match with the number of rows for this 
 | 
						|
         particular iscsiNode in iscsiConnectionAttributesTable.
 | 
						|
         "
 | 
						|
    ::= {   eqliscsiSnapshotStatusEntry 2 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSnapshotStatusLostRaidBlocksAction  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        mark-valid  (1),
 | 
						|
                        zero-out    (2)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-write      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies what action administrator wants to take on lost raid blocks."
 | 
						|
    ::=   {eqliscsiSnapshotStatusEntry 10 }
 | 
						|
 | 
						|
 | 
						|
--*************************************************************************
 | 
						|
 | 
						|
-- The Admin Group
 | 
						|
 | 
						|
eqliscsiAdminGroup OBJECT IDENTIFIER ::= { eqliscsiTarget 9 }
 | 
						|
 | 
						|
eqliscsiLocalMemberId OBJECT-TYPE
 | 
						|
   SYNTAX            Unsigned32
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "EqualLogic-Dynamic
 | 
						|
                      A number which uniquely identifies this instance of the 
 | 
						|
                      Equallogic SNMP agent within the group. This
 | 
						|
                      number will the same as the corresponding MemberIndex for this
 | 
						|
                      array in the eqlMemberTable."
 | 
						|
   ::=   {eqliscsiAdminGroup 1}
 | 
						|
 | 
						|
eqliscsiLocalMemberIdLow OBJECT-TYPE
 | 
						|
   SYNTAX            Unsigned32
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "EqualLogic-Dynamic
 | 
						|
                      A number which uniquely identifies this instance of the 
 | 
						|
                      Equallogic SNMP agent within the group. This
 | 
						|
                      number will the same as the corresponding MemberIndex for this
 | 
						|
                      array in the eqlMemberTable."
 | 
						|
   ::=   {eqliscsiAdminGroup 2}
 | 
						|
 | 
						|
eqliscsiLocalMemberIdHigh OBJECT-TYPE
 | 
						|
   SYNTAX            Unsigned32
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "EqualLogic-Dynamic
 | 
						|
                      A number which uniquely identifies this instance of the 
 | 
						|
                      Equallogic SNMP agent within the group. This
 | 
						|
                      number will the same as the corresponding MemberIndex for this
 | 
						|
                      array in the eqlMemberTable."
 | 
						|
   ::=   {eqliscsiAdminGroup 3}
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeAdminGroup OBJECT IDENTIFIER ::= { eqliscsiTarget 10 }
 | 
						|
 | 
						|
eqliscsiLastVolumeIndex OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     This object represents the highest numeric index that 
 | 
						|
                     any row in the eqliscsiVolumeTable has. An application 
 | 
						|
                     can use this value to determine an index with which to 
 | 
						|
                     create an additional row in that table without scanning
 | 
						|
                     the entire table for a usable index."
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 1 } 
 | 
						|
 | 
						|
eqliscsiVolumeIndexLow OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     This object represents the highest numeric index that 
 | 
						|
                     any row in the eqliscsiVolumeTable has. An application 
 | 
						|
                     can use this value to determine an index with which to 
 | 
						|
                     create an additional row in that table without scanning
 | 
						|
                     the entire table for a usable index."
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 2 } 
 | 
						|
 | 
						|
eqliscsiVolumeIndexHigh OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     This object represents the highest numeric index that 
 | 
						|
                     any row in the eqliscsiVolumeTable has. An application 
 | 
						|
                     can use this value to determine an index with which to 
 | 
						|
                     create an additional row in that table without scanning
 | 
						|
                     the entire table for a usable index."
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 3 } 
 | 
						|
 | 
						|
eqliscsiVolumeLowPsvId0 OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     first word of low volume PsvId"
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 4 } 
 | 
						|
 | 
						|
eqliscsiVolumeLowPsvId1 OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     second word of low volume PsvId"
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 5 } 
 | 
						|
 | 
						|
eqliscsiVolumeLowPsvId2 OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     third word of low volume PsvId"
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 6 } 
 | 
						|
 | 
						|
eqliscsiVolumeLowPsvId3 OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     fourth word of low volume PsvId"
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 7 } 
 | 
						|
 | 
						|
eqliscsiVolumeHighPsvId0 OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     first word of high volume PsvId"
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 8 } 
 | 
						|
 | 
						|
eqliscsiVolumeHighPsvId1 OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     second word of high volume PsvId"
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 9 } 
 | 
						|
 | 
						|
eqliscsiVolumeHighPsvId2 OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     third word of high volume PsvId"
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 10 } 
 | 
						|
 | 
						|
eqliscsiVolumeHighPsvId3 OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic 
 | 
						|
                     fourth word of high volume PsvId"
 | 
						|
    ::=  { eqliscsiVolumeAdminGroup 11 } 
 | 
						|
 | 
						|
eqliscsiSnapshotAdminGroup OBJECT IDENTIFIER ::= { eqliscsiTarget 11 }
 | 
						|
 | 
						|
eqliscsiLastSnapshotIndex OBJECT-TYPE
 | 
						|
   SYNTAX            Unsigned32
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "EqualLogic-Dynamic
 | 
						|
                     This object represents the highest numeric index that 
 | 
						|
                     any row in the eqliscsiSnapshotTable has. An application 
 | 
						|
                     can use this value to determine an index with which to 
 | 
						|
                     create an additional row in that table without scanning
 | 
						|
                     the entire table for a usable index."
 | 
						|
   ::= { eqliscsiSnapshotAdminGroup 1 }
 | 
						|
 | 
						|
eqliscsiTargetAdminGroup OBJECT IDENTIFIER ::= { eqliscsiTarget 35 }
 | 
						|
 | 
						|
eqliscsiLastTargetIndex OBJECT-TYPE
 | 
						|
   SYNTAX            Unsigned32
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "EqualLogic-Dynamic
 | 
						|
                     This object represents the highest numeric index that 
 | 
						|
                     any row in the eqliscsiTargetTable has. An application 
 | 
						|
                     can use this value to determine an index with which to 
 | 
						|
                     create an additional row in that table without scanning
 | 
						|
                     the entire table for a usable index."
 | 
						|
   ::= { eqliscsiTargetAdminGroup 1 }
 | 
						|
 | 
						|
-- ********************************************************************************
 | 
						|
--   Equallogic Node Table:
 | 
						|
--       provides a mapping between the iSCSI nodes in the the standard iSCSI MIB
 | 
						|
--       and the Equallogic proprietary MIBs
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiNodeTable OBJECT-TYPE
 | 
						|
   SYNTAX   SEQUENCE OF EqliscsiNodeEntry
 | 
						|
   MAX-ACCESS  not-accessible
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "EqualLogic-Dynamic iscsi Node Table:
 | 
						|
               maintains a mapping of the iscsi Node indeces 
 | 
						|
               back to the eql private volume and snapshot Mibs"
 | 
						|
   ::= { eqliscsiObjects 8 } 
 | 
						|
 | 
						|
eqliscsiNodeEntry OBJECT-TYPE
 | 
						|
   SYNTAX    EqliscsiNodeEntry
 | 
						|
   MAX-ACCESS  not-accessible
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "An entry containing the aformentioned mapping. The value of
 | 
						|
               eqliscsiSnapshotIndex will be zero (0) for those nodes that represent 
 | 
						|
               volumes rather than snapshots."
 | 
						|
   INDEX       { eqliscsiNodeIndex } 
 | 
						|
   
 | 
						|
   ::= { eqliscsiNodeTable 1 } 
 | 
						|
 | 
						|
EqliscsiNodeEntry ::= 
 | 
						|
   SEQUENCE {
 | 
						|
      eqliscsiNodeIndex Unsigned32,
 | 
						|
      eqliscsiNodeLocalMemberId Unsigned32,
 | 
						|
      eqliscsiNodeVolumeIndex Unsigned32,
 | 
						|
      eqliscsiNodeSnapshotIndex Unsigned32
 | 
						|
   }
 | 
						|
 | 
						|
eqliscsiNodeIndex OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-only
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION " The node index of the iSCSI target node. This will correspond to 
 | 
						|
               a value of iscsiNodeIndex, eqliscsiVOlumeNodeIndex, 
 | 
						|
               or eqliscsiSnapshotIndex. The indeces are allocated such that even values
 | 
						|
               of this object repesent snapshots and odd values represent volumes."
 | 
						|
 | 
						|
   ::= { eqliscsiNodeEntry 1 }
 | 
						|
 | 
						|
eqliscsiNodeLocalMemberId OBJECT-TYPE
 | 
						|
   SYNTAX            Unsigned32
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "EqualLogic-Dynamic
 | 
						|
                      A number which uniquely identifies this instance of the 
 | 
						|
                      Equallogic SNMP agent within the group. This
 | 
						|
                      number will the same as the corresponding MemberIndex for this
 | 
						|
                      array in the eqlMemberTable."
 | 
						|
   ::= {eqliscsiNodeEntry 2 } 
 | 
						|
 | 
						|
eqliscsiNodeVolumeIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing a volume in the
 | 
						|
                    eqliscsiVolumeTable. An instance here will reflect a specific instance
 | 
						|
                    in the eqliscsiVolumeTable and/or eqliscsiSnapshotTable."  
 | 
						|
   ::= { eqliscsiNodeEntry 3 } 
 | 
						|
 | 
						|
 | 
						|
eqliscsiNodeSnapshotIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index which identifies a volume SnapShot.
 | 
						|
                    in the eqliscsiSnapshotTable. If the conceptiual row in this table does 
 | 
						|
                    NOT reflect a snapshot, this instance of the variable will be set to 
 | 
						|
                    zero (0)."  
 | 
						|
    ::=  {  eqliscsiNodeEntry 4 }
 | 
						|
 | 
						|
 | 
						|
 | 
						|
 | 
						|
--
 | 
						|
-- Target Authorization Attributes Table : 
 | 
						|
-- 
 | 
						|
-- This table specifies the credentials that the target will use
 | 
						|
-- to identify itself TO A CHALLENGING INITIATOR. 
 | 
						|
-- 
 | 
						|
 | 
						|
eqliscsiVolumeAuthAttributesTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeAuthAttributesEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      A list of identities that the PSA uses to  authenticate itself to
 | 
						|
      initiators"
 | 
						|
::= { eqliscsiTarget 12 }
 | 
						|
 | 
						|
eqliscsiVolumeAuthAttributesEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeAuthAttributesEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "An entry (row) containing management information
 | 
						|
     applicable to a particular target node's authorized
 | 
						|
     initiator identity."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
::= { eqliscsiVolumeAuthAttributesTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeAuthAttributesEntry ::= SEQUENCE {
 | 
						|
    eqliscsiVolumeAuthRowStatus          RowStatus,
 | 
						|
    eqliscsiVolumeAuthIdentity           RowPointer
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolumeAuthRowStatus OBJECT-TYPE
 | 
						|
    SYNTAX        RowStatus
 | 
						|
    MAX-ACCESS    read-create
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The status of the row."
 | 
						|
::= { eqliscsiVolumeAuthAttributesEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeAuthIdentity OBJECT-TYPE
 | 
						|
    SYNTAX        RowPointer
 | 
						|
    MAX-ACCESS    read-create
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "A pointer to the corresponding IPS-AUTH MIB 
 | 
						|
         ipsAuthCredChapAttributesEntry that contains the  
 | 
						|
         chap credentials which this volume will use to 
 | 
						|
         authenticate itself to initiators requiring 
 | 
						|
         CHAP authentication"
 | 
						|
    REFERENCE
 | 
						|
        "IPS-AUTH MIB"
 | 
						|
::= { eqliscsiVolumeAuthAttributesEntry 2 }
 | 
						|
 | 
						|
--
 | 
						|
-- Volume Binding Table : 
 | 
						|
-- 
 | 
						|
-- This table specifies the specific members of the group that
 | 
						|
-- a particular volume may occupy
 | 
						|
-- 
 | 
						|
 | 
						|
eqliscsiVolumeBindingTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeBindingEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      A table that specifies the specific members of the group that
 | 
						|
      a particular volume may occupy"
 | 
						|
::= { eqliscsiTarget 13 }
 | 
						|
 | 
						|
eqliscsiVolumeBindingEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeBindingEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "An entry (row) containing a reference to a specific volume and a 
 | 
						|
      specific member where that volume's pages can exist.If no entry exists
 | 
						|
      for a particular volume, the member page allocation will be determined
 | 
						|
      by the system."
 | 
						|
    AUGMENTS        { eqliscsiVolumeMemberEntry }
 | 
						|
::= { eqliscsiVolumeBindingTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeBindingEntry ::= SEQUENCE {
 | 
						|
    eqliscsiVolumeBindingRowStatus       RowStatus
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolumeBindingRowStatus OBJECT-TYPE
 | 
						|
    SYNTAX        RowStatus
 | 
						|
    MAX-ACCESS    read-create
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The status of the row."
 | 
						|
::= { eqliscsiVolumeBindingEntry 1 }
 | 
						|
 | 
						|
----------------------------------------------------------------------
 | 
						|
 | 
						|
-- Primary Site Volume replication control MIBs
 | 
						|
--
 | 
						|
--
 | 
						|
 | 
						|
--
 | 
						|
-- Site table
 | 
						|
-- 
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeReplSiteEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent"
 | 
						|
::= { eqliscsiTarget 14 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeReplSiteEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    INDEX           { eqliscsiVolumeReplSiteIndex }
 | 
						|
::= { eqliscsiVolumeReplSiteTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeReplSiteEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolumeReplSiteIndex               SiteIndex,
 | 
						|
   eqliscsiVolumeReplSiteRowStatus           RowStatus,
 | 
						|
   eqliscsiVolumeReplSiteName                DisplayString,
 | 
						|
   eqliscsiVolumeReplSiteIpAddr          IpAddress,
 | 
						|
   eqliscsiVolumeReplSiteControlCredentials  RowPointer,
 | 
						|
   eqliscsiVolumeReplControlTargetIscsiName  OCTET STRING,
 | 
						|
   eqliscsiVolumeReplSiteSNMPContext         DisplayString,
 | 
						|
   eqliscsiVolumeReplSiteContact             DisplayString,
 | 
						|
   eqliscsiVolumeReplSiteEmail               DisplayString,
 | 
						|
   eqliscsiVolumeReplSitePhone               DisplayString,
 | 
						|
   eqliscsiVolumeReplSiteMobile              DisplayString,
 | 
						|
   eqliscsiVolumeReplSiteDescription         UTFString,
 | 
						|
   eqliscsiVolumeReplSiteSpaceAllocated       Unsigned32,
 | 
						|
   eqliscsiVolumeReplSiteSpaceUsed            Unsigned32,
 | 
						|
   eqliscsiVolumeReplControlChannelStatus    INTEGER,
 | 
						|
   eqliscsiVolumeReplSiteAdminStatus    INTEGER,
 | 
						|
   eqliscsiVolumeReplSiteTotalNumSnapshots   Unsigned32,
 | 
						|
   eqliscsiVolumeReplSiteSpaceSubscribed     Unsigned32,
 | 
						|
   eqliscsiVolumeReplSiteInetAddrType          InetAddressType,
 | 
						|
   eqliscsiVolumeReplSiteInetAddr              InetAddress,
 | 
						|
   eqliscsiVolumeReplSiteNASPartnershipId    Unsigned32,
 | 
						|
   eqliscsiVolumeReplSiteBlockState          StatusEnabledDefault,
 | 
						|
   eqliscsiVolumeReplSiteNASState            StatusDisabledDefault,
 | 
						|
   eqliscsiVolumeReplSiteType                INTEGER
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteIndex    OBJECT-TYPE
 | 
						|
   SYNTAX        SiteIndex 
 | 
						|
   MAX-ACCESS    not-accessible
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "A unique 32 bit identifier for this row"
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteRowStatus OBJECT-TYPE           
 | 
						|
   SYNTAX RowStatus
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "The status of the row"
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteName  OBJECT-TYPE              
 | 
						|
   SYNTAX   DisplayString(SIZE(1..64))
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "A concise, human readable string indentifier for the site,
 | 
						|
       for example: Boston HQ"
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 3 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteIpAddr  OBJECT-TYPE            
 | 
						|
   SYNTAX IpAddress
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION   "EQL-SECONDARY-KEY
 | 
						|
       This field is deprecated and will be unsupported in the next release."
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 4 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteControlCredentials  OBJECT-TYPE
 | 
						|
   SYNTAX RowPointer
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
        "A pointer to the corresponding IPS-AUTH MIB 
 | 
						|
         ipsAuthCredChapAttributesEntry that contains the  
 | 
						|
         chap credentials which this PSA will use to 
 | 
						|
         authenticate itself to replica targets for management 
 | 
						|
         requiring operations."
 | 
						|
    REFERENCE
 | 
						|
        "IPS-AUTH MIB"
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 5 }
 | 
						|
 | 
						|
eqliscsiVolumeReplControlTargetIscsiName OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..223))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The iSCSI name of the group-wide target that is 
 | 
						|
                     used to encapsulate replication control commands."
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 6 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteSNMPContext OBJECT-TYPE        
 | 
						|
   SYNTAX DisplayString
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "The SNMP context that will be used by applications at the
 | 
						|
       local site to browse MIBs on the remote site."
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 7 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteContact OBJECT-TYPE
 | 
						|
    SYNTAX          DisplayString (SIZE(0..64))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
        "This field contains the full name of the replication site administrator."
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 8 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteEmail OBJECT-TYPE
 | 
						|
    SYNTAX          DisplayString (SIZE(0..64))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
        "This field specifies the email address of the replication site administrator."
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 9 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSitePhone OBJECT-TYPE
 | 
						|
    SYNTAX          DisplayString (SIZE(0..32))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
        "This field specifies the phone number of the replication site administrator."
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 10 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteMobile OBJECT-TYPE
 | 
						|
    SYNTAX          DisplayString (SIZE(0..32))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
        "This field specifies the cell phone number of the replication site administrator."
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 11 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteDescription OBJECT-TYPE
 | 
						|
    SYNTAX          UTFString(SIZE(0..64))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
      "This field contains a detailed description of the site."
 | 
						|
    ::=  { eqliscsiVolumeReplSiteEntry  12 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteSpaceAllocated OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The total amount of pool space reserved for use by
 | 
						|
               the site. Replication may be set up as needed by the
 | 
						|
               administrators at the site as long as the total required 
 | 
						|
               reserve does not exceed this value."
 | 
						|
    ::=  { eqliscsiVolumeReplSiteEntry  13 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteSpaceUsed     OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The amount of reserve space already used by replicated volumes 
 | 
						|
               configured by the site administrator. This value may not exceed 
 | 
						|
               the corresponding value for eqliscsiVolumeReplSiteSpaceAllocated"
 | 
						|
    ::=  { eqliscsiVolumeReplSiteEntry  14 }
 | 
						|
 | 
						|
eqliscsiVolumeReplControlChannelStatus     OBJECT-TYPE
 | 
						|
   SYNTAX      INTEGER {
 | 
						|
                 ipaddress-not-configured(1),
 | 
						|
                 generic-error(2),
 | 
						|
                 control-target-not-configured(3),
 | 
						|
                 control-target-not-present-at-replica-site(4),
 | 
						|
                 control-credentials-not-configured(5),
 | 
						|
                 authentication-failed(6),
 | 
						|
                 logged-in(7),
 | 
						|
                 logged-out(8),
 | 
						|
                 paused(9)
 | 
						|
   }
 | 
						|
   MAX-ACCESS  read-only
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION " The current status of the control channel to replica site."
 | 
						|
    ::=  { eqliscsiVolumeReplSiteEntry  15 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteAdminStatus   OBJECT-TYPE
 | 
						|
   SYNTAX      INTEGER {
 | 
						|
               enabled(1),
 | 
						|
               paused(2)
 | 
						|
   }
 | 
						|
   MAX-ACCESS  read-write
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION " When set to pause, all the replications going to this replica site will be 
 | 
						|
                 temporarily suspended until set by the user to start.
 | 
						|
               "
 | 
						|
   DEFVAL     { enabled }
 | 
						|
    ::=  {  eqliscsiVolumeReplSiteEntry 16 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteTotalNumSnapshots     OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION " the total number of snapshots in secondary site"
 | 
						|
    ::=  { eqliscsiVolumeReplSiteEntry  17 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteSpaceSubscribed OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The total amount of pool space subscribed for use by
 | 
						|
               the site. Subscribed space is the advertised space 
 | 
						|
               for thin provisioned volumes. For classic volumes, subscribed
 | 
						|
               space is the volume size."
 | 
						|
    ::=  { eqliscsiVolumeReplSiteEntry  18 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteInetAddrType  OBJECT-TYPE            
 | 
						|
   SYNTAX InetAddressType
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION   "The well-known IP address of the group located at the
 | 
						|
       site. This will be the IP address to which iSCSI
 | 
						|
       replication traffic will be directed."
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 19 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteInetAddr  OBJECT-TYPE            
 | 
						|
   SYNTAX InetAddress
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION   "The well-known IP address of the group located at the
 | 
						|
       site. This will be the IP address to which iSCSI
 | 
						|
       replication traffic will be directed."
 | 
						|
::= { eqliscsiVolumeReplSiteEntry 20 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteNASPartnershipId OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The NAS replication PartnershipId. This partnershipId is Exastore 
 | 
						|
                way to keep track of a NAS partnership. If NAS replication is configured
 | 
						|
                This will be a non-zero Id. 0 will be used when NAS replication is not
 | 
						|
                configured on this partnership."
 | 
						|
    ::=  { eqliscsiVolumeReplSiteEntry  21 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteBlockState OBJECT-TYPE
 | 
						|
   SYNTAX      StatusEnabledDefault
 | 
						|
   MAX-ACCESS  read-write
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The state of this site for block replication."
 | 
						|
   DEFVAL     { enabled }
 | 
						|
    ::=  {  eqliscsiVolumeReplSiteEntry 22 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteNASState OBJECT-TYPE
 | 
						|
   SYNTAX      StatusDisabledDefault
 | 
						|
   MAX-ACCESS  read-write
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The state of this site for NAS replication."
 | 
						|
   DEFVAL     { disabled }
 | 
						|
    ::=  {  eqliscsiVolumeReplSiteEntry 23 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteType OBJECT-TYPE
 | 
						|
   SYNTAX      INTEGER{
 | 
						|
               normal(0),
 | 
						|
               external(1)
 | 
						|
   }
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "This field represents the site type. 0 is normal aka regular repl site. 1 is external site that is not an EQL array."
 | 
						|
   DEFVAL     { normal }
 | 
						|
    ::=  {  eqliscsiVolumeReplSiteEntry 24 }
 | 
						|
 | 
						|
--
 | 
						|
-- Volume Replication Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiVolumeReplicationTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeReplicationEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
     TimeoutCreate:60"
 | 
						|
::= { eqliscsiTarget 15 }
 | 
						|
 | 
						|
eqliscsiVolumeReplicationEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeReplicationEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeReplSiteIndex }
 | 
						|
::= { eqliscsiVolumeReplicationTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeReplicationEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolumeReplRowStatus        RowStatus,
 | 
						|
   eqliscsiVolumeReplAdminStatus      INTEGER,
 | 
						|
   eqliscsiVolumeReplRemoteIscsiName  OCTET STRING,
 | 
						|
   eqliscsiVolumeReplRemoteIscsiPort  Unsigned32,
 | 
						|
   eqliscsiVolumeReplRemotePsvId      OCTET STRING,
 | 
						|
   eqliscsiVolumeReplDiscardPolicy    INTEGER,
 | 
						|
   eqliscsiVolumeReplReserve          Unsigned32,
 | 
						|
   eqliscsiVolumeReplDeletionPolicy   INTEGER,
 | 
						|
   eqliscsiVolumeReplNumReplicas      Unsigned32,
 | 
						|
   eqliscsiVolumeReplPrimaryReserve   Unsigned32,
 | 
						|
   eqliscsiVolumeReplPrimaryBorrow    TruthValue,
 | 
						|
   eqliscsiVolumeReplManualReplStatus INTEGER,
 | 
						|
   eqliscsiVolumeReplCurLwMark        Integer32,
 | 
						|
   eqliscsiVolumeReplLwMark           Integer32,
 | 
						|
   eqliscsiVolumeReplSize             Integer32,
 | 
						|
   eqliscsiVolumeReplThinProvision    TruthValue,
 | 
						|
   eqliscsiVolumeReplMinThinReserve   Unsigned32,
 | 
						|
   eqliscsiVolumeReplThinWarnPercentage Unsigned32,
 | 
						|
   eqliscsiVolumeReplThinMaxGrowPercentage Unsigned32,
 | 
						|
   eqliscsiVolumeReplDynamicThinReserve   Unsigned32,
 | 
						|
   eqliscsiVolumeReplFailBackMode      INTEGER,
 | 
						|
   eqliscsiVolumeReplPromoteSeqNum    Counter64,
 | 
						|
   eqliscsiVolumeReplSyncAdminStatus   INTEGER,
 | 
						|
   eqliscsiVolumeReplSyncOperStatus    INTEGER,
 | 
						|
   eqliscsiVolumeReplTemplateReplicated   TruthValue,
 | 
						|
   eqliscsiVolumeReplThinClone           TruthValue
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolumeReplRowStatus   OBJECT-TYPE     
 | 
						|
   SYNTAX RowStatus
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "The status of the row"
 | 
						|
::= { eqliscsiVolumeReplicationEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeReplAdminStatus  OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      enabled(1),
 | 
						|
      disabled(2),
 | 
						|
      paused(3)
 | 
						|
      }
 | 
						|
   MAX-ACCESS      read-write
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION "This object is used to request a change 
 | 
						|
               in the current admin status of the replication
 | 
						|
               process. When read, it represents the current 
 | 
						|
               admin status.
 | 
						|
               If disabled, the replication can NEVER be restarted again."
 | 
						|
   DEFVAL   { enabled }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeReplRemoteIscsiName   OBJECT-TYPE 
 | 
						|
   SYNTAX OCTET STRING (SIZE (0..223))
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     " This field specifies the iSCSI target name 
 | 
						|
                     for the remote volume which serves as a 
 | 
						|
                     replica target."
 | 
						|
::= { eqliscsiVolumeReplicationEntry 3 }   
 | 
						|
 | 
						|
eqliscsiVolumeReplRemoteIscsiPort   OBJECT-TYPE 
 | 
						|
   SYNTAX           Unsigned32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current   
 | 
						|
    DESCRIPTION     " This field specifies the Internet Portocol port number 
 | 
						|
                     for the iSCSI target specified in the corresponding instance of 
 | 
						|
                     eqliscsiVolumeReplRemoteIscsiName. The target will be accessed using this port."
 | 
						|
    DEFVAL          { 3260 }   
 | 
						|
::= { eqliscsiVolumeReplicationEntry 4 }   
 | 
						|
 | 
						|
eqliscsiVolumeReplRemotePsvId OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     A 16 byte, universally unique identifier for
 | 
						|
                     the remote replica volume. The value for this 
 | 
						|
                     object is determined by the array 
 | 
						|
                     where the replica set is located."  
 | 
						|
::= { eqliscsiVolumeReplicationEntry 5 }   
 | 
						|
 | 
						|
eqliscsiVolumeReplDiscardPolicy     OBJECT-TYPE 
 | 
						|
   SYNTAX INTEGER { 
 | 
						|
      overRun(1),
 | 
						|
      discard(2)
 | 
						|
   }
 | 
						|
   MAX-ACCESS      read-create      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION "In the event that the replication process cannot  
 | 
						|
               complete the transfer of the volume to the replica
 | 
						|
               site, the action taken on the 
 | 
						|
               incomplete replica is one of these:
 | 
						|
               1) overrun - complete the in progress replica
 | 
						|
               2) discard - destry the in progress replica and restart a new one"
 | 
						|
  DEFVAL { overRun }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 6 }   
 | 
						|
 | 
						|
eqliscsiVolumeReplReserve  OBJECT-TYPE 
 | 
						|
   SYNTAX Unsigned32
 | 
						|
   MAX-ACCESS      read-create      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION 
 | 
						|
        "
 | 
						|
        This value represents the percentage of space reserved for replication at remote site.
 | 
						|
        The value effectively determines the maximum number of replicas that can be 
 | 
						|
        maintained at the remote site. 
 | 
						|
        The default value is good for maintaining one replica.
 | 
						|
        "
 | 
						|
   DEFVAL { 200 }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 7 }   
 | 
						|
 | 
						|
eqliscsiVolumeReplDeletionPolicy     OBJECT-TYPE 
 | 
						|
   SYNTAX INTEGER { 
 | 
						|
      local-only(1),
 | 
						|
      remote(2)
 | 
						|
   }
 | 
						|
   MAX-ACCESS      read-create      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION "The depth of deletion desired when replication at the local 
 | 
						|
                array is disabled for an associated primary volume. The choices are 
 | 
						|
                as follows:
 | 
						|
                  local_only: Only the local references to the remote replica sets 
 | 
						|
                              will be removed. The remote replica sets will remain 
 | 
						|
                              intact and will need to be managed at the remote site.
 | 
						|
                  remote: The remote replica sets will be deleted. This will destroy 
 | 
						|
                          all of the remote data.
 | 
						|
 | 
						|
               Note that setting the value to 'remote' will cause the delete operation
 | 
						|
               to fail if there is no connectivity to the remote site. If the deletion needs to 
 | 
						|
               proceed regardless of the state of the remote site, the local_only policy shoud be
 | 
						|
               used"
 | 
						|
   DEFVAL { remote }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 8 }   
 | 
						|
 | 
						|
eqliscsiVolumeReplNumReplicas   OBJECT-TYPE
 | 
						|
   SYNTAX Unsigned32
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "The number of replicas present at the replica site
 | 
						|
                    for this volume.
 | 
						|
                    The value of this object matches with number of rows in eqliscsiRemoteReplicaTable
 | 
						|
                    that correspond to this replication entry."
 | 
						|
   DEFVAL          { 0 }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 9 }
 | 
						|
 | 
						|
eqliscsiVolumeReplPrimaryReserve   OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32 (5..200)
 | 
						|
   MAX-ACCESS      read-write
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "
 | 
						|
                    The space reserved on the primary site to keep track of changes occurred between replications.
 | 
						|
                    The value is represented as percentage of actual volume size. It is recommended 
 | 
						|
                    to keep this value 100 if fast fail-back is not enabled. If the value is less than 100, replication will fail 
 | 
						|
                    if the space is not sufficient to keep track of the changes. It is recommended to 
 | 
						|
                    keep this value 200 if fast fail-back is enabled.
 | 
						|
                   "
 | 
						|
   DEFVAL          { 100 }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 10 }
 | 
						|
 | 
						|
eqliscsiVolumeReplPrimaryBorrow   OBJECT-TYPE
 | 
						|
   SYNTAX          TruthValue
 | 
						|
   MAX-ACCESS      read-write
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "
 | 
						|
                    When the space reserved for replication is not sufficient to keep track of volume changes,
 | 
						|
                    space will be borrowed from free space if the value of this object is true.
 | 
						|
                    Space will not be borrowed when the value is false. Setting this variable to true doesn't
 | 
						|
                    gaurantee replication to succeed as there may be no free space available to borrow.
 | 
						|
                    The borrwed space is returned back to the pool after the replication is complete.
 | 
						|
                   "
 | 
						|
   DEFVAL          { true }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 11 }
 | 
						|
 | 
						|
eqliscsiVolumeReplManualReplStatus  OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      enabled(1),
 | 
						|
      disabled(2),
 | 
						|
      done(3)
 | 
						|
      }
 | 
						|
   MAX-ACCESS      read-write
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION "
 | 
						|
                Enabling manual replication will allow the replica snaps on the primary and secondary groups to be visible
 | 
						|
                to iscsi clients.  When user connects to primary repl snap and finishes the data transfer, user can set it do done. 
 | 
						|
                The done state will be set to disabled after secondary site admin finishes the data transfer on 
 | 
						|
                secondary site and indicates done on secondary site."
 | 
						|
   DEFVAL   { disabled }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 12 }
 | 
						|
 | 
						|
eqliscsiVolumeReplCurLwMark OBJECT-TYPE
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the smallest volume size in MB since the last replication 
 | 
						|
                     that this volume has been shrunk down to.  This is used to track volumes shrinking 
 | 
						|
                     and then growing so that the secondary side knows to release the pages when the 
 | 
						|
                     volume is replicated.
 | 
						|
                     Note: Volume size is round to a multiple of 15MB. "
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 13 }
 | 
						|
 | 
						|
eqliscsiVolumeReplLwMark OBJECT-TYPE
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is eqliscsiVolumeCurLwMark for the current replication started. 
 | 
						|
                     This is used to track volumes shrinking and then growing so that the secondary 
 | 
						|
                     side knows to release the pages when the volume is replicated.
 | 
						|
                     Note: Volume size is round to a multiple of 15MB. "
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 14 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeReplSize OBJECT-TYPE
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is eqliscsiVolumeSize for the current replication started."
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 15 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeReplThinProvision OBJECT-TYPE
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is eqliscsiVolumeThinProvision for the current replication started."
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 16 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeReplMinThinReserve OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is eqliscsiVolumeMinThinReserve for the current replication started."
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 17 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeReplThinWarnPercentage OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is eqliscsiVolumeThinWarnPercentage for the current replication started."
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 18 }
 | 
						|
 | 
						|
eqliscsiVolumeReplThinMaxGrowPercentage OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is eqliscsiVolumeThinMaxGrowPercentage for the current replication started."
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 19 }
 | 
						|
 | 
						|
eqliscsiVolumeReplDynamicThinReserve OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is eqliscsiVolumeDynamicThinReserve  for the current replication started."
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 20 }
 | 
						|
 | 
						|
eqliscsiVolumeReplFailBackMode OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                    normal(0),
 | 
						|
                    fast(1)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether fast fail-back is enabled for this replication or not. By default fail-back will operate in regular mode. If user enables fast fail-back mode, primary site needs to keep the last successful replication snap ie fail-back snap. When customers upgrade to 3.2, the existing volumes will operate in regular fail-back mode."
 | 
						|
    DEFVAL         { normal }
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 21 }
 | 
						|
 | 
						|
eqliscsiVolumeReplPromoteSeqNum OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether this replicaset was demoted to failback replicaset and later promoted. This value will be set to non-zero if during promote we couldn't communicating to the remote site.
 | 
						|
                               The value will be the sequence number on the volume during the promote."
 | 
						|
    DEFVAL         { 0 }
 | 
						|
::=   { eqliscsiVolumeReplicationEntry 22 }
 | 
						|
 | 
						|
eqliscsiVolumeReplTemplateReplicated  OBJECT-TYPE
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies if the Template has been successfully replicated"
 | 
						|
    DEFVAL          {false}
 | 
						|
    ::=   { eqliscsiVolumeReplicationEntry 23 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSyncAdminStatus OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      disabled(0),
 | 
						|
      enabled(1)
 | 
						|
      }
 | 
						|
   MAX-ACCESS      read-create
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "Enabling sync replication will allow the replica volume to become online at the end of first successful replication. 
 | 
						|
                    The changes to volume on primary will be comitted to the replica volume on secondary synchronously.
 | 
						|
                    When the AdminStatus is set to disabled the replica volume on the secondary will be brought offline."
 | 
						|
   DEFVAL   { disabled }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 24 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSyncOperStatus OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      disabled(0),
 | 
						|
      waiting-for-first-sync(1),
 | 
						|
      first-sync-done(2)
 | 
						|
      }
 | 
						|
   MAX-ACCESS      read-create
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "When SyncAdminStatus is enabled the OperStatus indicates the state of sync replication. The replica volume on the secondary is brought
 | 
						|
                    online at the end of the first successful replication. The sync repl will then start xfering data to the replica volume. The states
 | 
						|
                    waiting-for-first-sync and first-sync-done indicate the SyncRepl operating states." 
 | 
						|
   DEFVAL   { disabled }
 | 
						|
::= { eqliscsiVolumeReplicationEntry 25 }
 | 
						|
 | 
						|
eqliscsiVolumeReplThinClone  OBJECT-TYPE
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies if the Volume is a Thin Clone Volume."
 | 
						|
    DEFVAL          {false}
 | 
						|
    ::=   { eqliscsiVolumeReplicationEntry 26 }
 | 
						|
 | 
						|
--
 | 
						|
-- Volume Replication Status Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiVolumeReplicationStatusTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeReplicationStatusEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Dynamic"
 | 
						|
::= { eqliscsiTarget 16 }
 | 
						|
 | 
						|
eqliscsiVolumeReplicationStatusEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeReplicationStatusEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeReplSiteIndex }
 | 
						|
::= { eqliscsiVolumeReplicationStatusTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeReplicationStatusEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolumeReplOperStatus    INTEGER,
 | 
						|
   eqliscsiVolumeReplMBRemaining   Counter64,
 | 
						|
   eqliscsiVolumeReplMBCompleted   Counter64,
 | 
						|
   eqliscsiVolumeReplCurrentSnapshot RowPointer,
 | 
						|
   eqliscsiVolumeReplCancel        TruthValue,
 | 
						|
   eqliscsiVolumeRemoteReplReserveIncrNeeded   Unsigned32,
 | 
						|
   eqliscsiVolumeReplFailbackSnap  RowPointer
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolumeReplOperStatus  OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      disabled(1),
 | 
						|
      inProgress(2),
 | 
						|
      waiting(3),
 | 
						|
      farEndDown(4),
 | 
						|
      authFailure(5),
 | 
						|
      completed(6),
 | 
						|
      paused(7),
 | 
						|
      remoteResizeFailed(8),
 | 
						|
      remotePaused(9),
 | 
						|
      partnerPausedLocal(10),
 | 
						|
      failed(11),
 | 
						|
      remoteReplReserveLow(12),
 | 
						|
      nomoresnapallowed(13),
 | 
						|
      remoteReplReserveInvalid(14),
 | 
						|
      cancelling(15),
 | 
						|
      pendingDataTransfer(16),
 | 
						|
      manualDataTransferInProgress(17),
 | 
						|
      remoteDisallowDowngradesNotSet(18),
 | 
						|
      remotePartnerNeedsUpgrade(19)
 | 
						|
      }
 | 
						|
   MAX-ACCESS      read-only      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION "The current operational status of the replication
 | 
						|
               process."
 | 
						|
::= { eqliscsiVolumeReplicationStatusEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeReplMBRemaining   OBJECT-TYPE
 | 
						|
   SYNTAX Counter64
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "If a transfer of replica data is in progress, the 
 | 
						|
                    count of MB successfully transferred to the 
 | 
						|
                    replica site will be here. If no transfer is in 
 | 
						|
                    progress, this object will read zero (0)."
 | 
						|
::= { eqliscsiVolumeReplicationStatusEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeReplMBCompleted   OBJECT-TYPE
 | 
						|
   SYNTAX Counter64
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "If a transfer of replica data is in progress, the 
 | 
						|
                    count of MB remaining to be transferred to the 
 | 
						|
                    replica site will be here. If no transfer is in 
 | 
						|
                    progress, this object will read zero (0)."
 | 
						|
::= { eqliscsiVolumeReplicationStatusEntry 3 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeReplCurrentSnapshot   OBJECT-TYPE
 | 
						|
   SYNTAX RowPointer
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "The value of this represents the instance of the snapshot in eqliscsiSnapshotTable 
 | 
						|
                    that is currently being replicated.
 | 
						|
                    If there is no replication in progress, the value will be set to NULL.
 | 
						|
                    "
 | 
						|
::= { eqliscsiVolumeReplicationStatusEntry 5 }
 | 
						|
 | 
						|
eqliscsiVolumeReplCancel   OBJECT-TYPE
 | 
						|
   SYNTAX TruthValue
 | 
						|
   MAX-ACCESS      read-write
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "
 | 
						|
                    Setting this variable to true will cause cancellation of any replication that is in
 | 
						|
                    progress.
 | 
						|
                   "
 | 
						|
::= { eqliscsiVolumeReplicationStatusEntry 6 }
 | 
						|
 | 
						|
eqliscsiVolumeRemoteReplReserveIncrNeeded   OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "In percentage. remote replica reserve needs to be increased by this value for replication to the partner to continue. Valid only in remoteReplReserveLow and remoteReplReserveInvalid states."
 | 
						|
 | 
						|
::= { eqliscsiVolumeReplicationStatusEntry 7 }
 | 
						|
 | 
						|
eqliscsiVolumeReplFailbackSnap   OBJECT-TYPE
 | 
						|
   SYNTAX          RowPointer
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "This pointer points to the fast fail-back snap kept in the local replication reserve."
 | 
						|
 | 
						|
::= { eqliscsiVolumeReplicationStatusEntry 8 }
 | 
						|
 | 
						|
--
 | 
						|
--    Remote Replica Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiRemoteReplicaTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiRemoteReplicaEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent"
 | 
						|
::= { eqliscsiTarget 17 }
 | 
						|
 | 
						|
eqliscsiRemoteReplicaEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiRemoteReplicaEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex, eqliscsiVolumeReplSiteIndex, eqliscsiRemoteVolumeIndex, eqliscsiRemoteSnapIndex }
 | 
						|
::= { eqliscsiRemoteReplicaTable 1 }
 | 
						|
 | 
						|
EqliscsiRemoteReplicaEntry ::= SEQUENCE {
 | 
						|
   eqliscsiRemoteVolumeIndex     Unsigned32,
 | 
						|
   eqliscsiRemoteSnapIndex       Unsigned32,
 | 
						|
   eqliscsiRemoteReplName        OCTET STRING,
 | 
						|
   eqliscsiRemoteReplISCSIName   OCTET STRING,
 | 
						|
   eqliscsiRemoteReplPsvId       OCTET STRING,
 | 
						|
   eqliscsiRemoteReplAdminStatus INTEGER,
 | 
						|
   eqliscsiRemoteReplTimeStamp   Counter32,
 | 
						|
   eqliscsiRemoteReplSnapColIndex Unsigned32,
 | 
						|
   eqliscsiRemoteReplScheduleIndex Unsigned32,
 | 
						|
   eqliscsiRemoteReplLocalMemberId Unsigned32
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiRemoteVolumeIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      not-accessible     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing a remote volume.
 | 
						|
                     The index is the same as the value for eqliscsiVolumeIndex on
 | 
						|
                     the remote site."  
 | 
						|
::= { eqliscsiRemoteReplicaEntry 1 }
 | 
						|
 | 
						|
eqliscsiRemoteSnapIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      not-accessible     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing a snapshot.
 | 
						|
                     The index is the same as the value for eqliscsiSnapshotIndex on
 | 
						|
                     the remote site."  
 | 
						|
::= { eqliscsiRemoteReplicaEntry 2 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiRemoteReplName  OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the friendly name used to identify the replica.
 | 
						|
                     The name is auto-generated. The name is unique between replicas of a single
 | 
						|
                     volume at a particular site."
 | 
						|
    ::= {   eqliscsiRemoteReplicaEntry 3 }  
 | 
						|
 | 
						|
eqliscsiRemoteReplISCSIName OBJECT-TYPE
 | 
						|
   SYNTAX        OCTET STRING (SIZE (0..223))  
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "The iscsi name of the volume for which this site
 | 
						|
      is keeping replicas."
 | 
						|
::= { eqliscsiRemoteReplicaEntry 4 }
 | 
						|
 | 
						|
eqliscsiRemoteReplPsvId OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     A universally unique 16 byte identifier for the remote replica."  
 | 
						|
::= { eqliscsiRemoteReplicaEntry 5 }
 | 
						|
 | 
						|
eqliscsiRemoteReplAdminStatus OBJECT-TYPE
 | 
						|
   SYNTAX        INTEGER {
 | 
						|
                 none(0),
 | 
						|
                 delete(1),
 | 
						|
                 in-progress(2),
 | 
						|
                 incomplete(3)
 | 
						|
   }
 | 
						|
   MAX-ACCESS    read-write
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "Manage the replica status. The row will be deleted from this table if value is set to delete. Status will be in-progress if this replica is currently getting replicated to the secondary site.
 | 
						|
      The replica will be set to incomplete if the replication is disabled."
 | 
						|
::= { eqliscsiRemoteReplicaEntry 6 }
 | 
						|
 | 
						|
eqliscsiRemoteReplTimeStamp OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "
 | 
						|
                     This field specifies the creation time of the replica.
 | 
						|
                     Time is represented as the time in seconds since 00:00:00 UTC, 1970-01-01.
 | 
						|
                    " 
 | 
						|
    ::= {   eqliscsiRemoteReplicaEntry 7 }
 | 
						|
 | 
						|
eqliscsiRemoteReplSnapColIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "
 | 
						|
                     This field specifies the index of the snap collection at remote site if this
 | 
						|
                     replica is part of a collection. Otherwise value will be zero. 
 | 
						|
                    " 
 | 
						|
    ::= {   eqliscsiRemoteReplicaEntry 8 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiRemoteReplScheduleIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
                    "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies the index of the schedule on the primary site that initiated
 | 
						|
                     create replica operation ie eqliscsiVolumeSnapshotPolicyIndex . 
 | 
						|
                     If this replica is not directly created by a schedule, but created as part of 
 | 
						|
                     replica collection creation and the replica collection is created by a schedule,
 | 
						|
                     the value of this field will still be set to index of the replica collection schedule.
 | 
						|
                     ie eqliscsiSnapCollectionPolicyIndex.
 | 
						|
                     This will be reset to zero when schedule is deleted.
 | 
						|
                    " 
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::= {   eqliscsiRemoteReplicaEntry 9 }
 | 
						|
 | 
						|
eqliscsiRemoteReplLocalMemberId OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
                    "
 | 
						|
                     This field represents eqliscsiLocalMemberId field of the snapshot index of the replica on secondary site."
 | 
						|
    ::= {   eqliscsiRemoteReplicaEntry 10 }
 | 
						|
 | 
						|
----------------------------------------------------------------------
 | 
						|
--
 | 
						|
-- Replica Site Volume replication control MIBs
 | 
						|
--
 | 
						|
 | 
						|
-- 
 | 
						|
-- ReplicaSet table
 | 
						|
-- 
 | 
						|
 | 
						|
eqliscsiReplicaSetTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiReplicaSetEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent"
 | 
						|
::= { eqliscsiTarget 18 }
 | 
						|
 | 
						|
eqliscsiReplicaSetEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiReplicaSetEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      " The Replica set consists of the base volume and the snapshots associated with this base volume."
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex }
 | 
						|
::= { eqliscsiReplicaSetTable 1 }
 | 
						|
 | 
						|
EqliscsiReplicaSetEntry ::= SEQUENCE {
 | 
						|
   eqliscsiReplicaSetPrimaryIscsiName  OCTET STRING,
 | 
						|
   eqliscsiReplicaSetReserve           Unsigned32,
 | 
						|
   eqliscsiReplicaSetSite              SiteIndex,
 | 
						|
   eqliscsiReplicaSetAdminStatus       INTEGER,
 | 
						|
   eqliscsiReplicaSetPromotePolicy     INTEGER,
 | 
						|
   eqliscsiReplicaSetManualReplStatus  INTEGER,
 | 
						|
   eqliscsiReplicaSetFailBackMode      INTEGER,
 | 
						|
   eqliscsiReplicaSetType              INTEGER,
 | 
						|
   eqliscsiReplicaSetAccess            INTEGER,
 | 
						|
   eqliscsiReplicaSetFailbackReserve   Unsigned32,
 | 
						|
   eqliscsiReplicaSetLSRPsvId          OCTET STRING,
 | 
						|
   eqliscsiReplicaSetOrigSize          Unsigned32,
 | 
						|
   eqliscsiReplicaSetPrimaryMemberId    Unsigned32,
 | 
						|
   eqliscsiReplicaSetPrimaryVolumeIndex Unsigned32,
 | 
						|
   eqliscsiReplicaSetPrimarySite        Unsigned32,
 | 
						|
   eqliscsiReplicaSetSyncAdminStatus    INTEGER,
 | 
						|
   eqliscsiReplicaSetTemplateReplicated TruthValue,
 | 
						|
   eqliscsiReplicaSetThinClone          TruthValue,
 | 
						|
   eqliscsiReplicaSetRemotePsvId        OCTET STRING
 | 
						|
}
 | 
						|
 | 
						|
 | 
						|
eqliscsiReplicaSetPrimaryIscsiName  OBJECT-TYPE
 | 
						|
   SYNTAX OCTET STRING (SIZE (0..223))
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "The iscsi name of the volume for which this site
 | 
						|
      is keeping replicas."
 | 
						|
::= { eqliscsiReplicaSetEntry 1 }
 | 
						|
 | 
						|
eqliscsiReplicaSetReserve    OBJECT-TYPE
 | 
						|
   SYNTAX Unsigned32
 | 
						|
   MAX-ACCESS read-create
 | 
						|
   STATUS   current
 | 
						|
   DESCRIPTION 
 | 
						|
     "
 | 
						|
     The value of this object specifies how much percentage of space reserved for replication.
 | 
						|
     This value matches with correspoding eqliscsiVolumeReplReserve value on the primary site.
 | 
						|
     The value is initialized and maintained by the control channel.
 | 
						|
     "
 | 
						|
   DEFVAL { 100 }
 | 
						|
::= { eqliscsiReplicaSetEntry 2 }
 | 
						|
 | 
						|
eqliscsiReplicaSetSite  OBJECT-TYPE
 | 
						|
   SYNTAX      SiteIndex
 | 
						|
   MAX-ACCESS  read-write
 | 
						|
   STATUS      current      
 | 
						|
   DESCRIPTION 
 | 
						|
       "Represents the value of eqliscsiReplicantSiteIndex that 
 | 
						|
        corresponds to the site to which this replica belongs."
 | 
						|
::= { eqliscsiReplicaSetEntry 3 }
 | 
						|
 | 
						|
eqliscsiReplicaSetAdminStatus  OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      stopped(1),
 | 
						|
      started(2)
 | 
						|
      }
 | 
						|
   MAX-ACCESS      read-write
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION "This object is used to request a change 
 | 
						|
               in the current admin status of the replication
 | 
						|
               process. When read, it represents the current 
 | 
						|
               admin status."
 | 
						|
::= { eqliscsiReplicaSetEntry 4 }
 | 
						|
 | 
						|
eqliscsiReplicaSetPromotePolicy  OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      default-iscsi-name(1),
 | 
						|
      primary-iscsi-name(2)
 | 
						|
      }
 | 
						|
   MAX-ACCESS      read-write
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION "This object represents the policy that is implemented when 
 | 
						|
               the replica set is promoted to a conventional volume. If the
 | 
						|
               value of this object is set to 1, the iscsi name of the target 
 | 
						|
               is generated uniquely using conventional rules. When set to 2, 
 | 
						|
               the target assumes the iscsi name of the primary volume. In this 
 | 
						|
               case, that name will be the same as the value for this instance of
 | 
						|
               eqliscsiReplicaSetPrimaryIscsiName."
 | 
						|
   DEFVAL { default-iscsi-name }
 | 
						|
::= { eqliscsiReplicaSetEntry 5 }
 | 
						|
 | 
						|
eqliscsiReplicaSetManualReplStatus  OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      enabled(1),
 | 
						|
      disabled(2),
 | 
						|
      done(3)
 | 
						|
      }
 | 
						|
   MAX-ACCESS      read-write
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION "This object is used to let the secondary know that the transfer of data
 | 
						|
                has completed for volumes using manual data transfer for replication."
 | 
						|
   DEFVAL   { disabled }
 | 
						|
::= { eqliscsiReplicaSetEntry 12 }
 | 
						|
 | 
						|
eqliscsiReplicaSetFailBackMode OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                    normal(0),
 | 
						|
                    fast(1)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the mode of fail-back. In a normal fail-back mode, to get primary site back in sync with secondary site volume, all the volume contents must be transferred back to primary site. In fast fail-back mode, only the changes since last successful replication will be sent back to primary site. primary site needs to keep the last successful replication snap ie fail-back snap. When customers upgrade to 3.2, the existing volumes will operate in normal fail-back mode.SNMP managers cannot set this field. The value of this field gets configured when the primary site field eqliscsiVolumeReplFailBackMode gets configured."
 | 
						|
    DEFVAL          {normal}
 | 
						|
::=   { eqliscsiReplicaSetEntry 13 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiReplicaSetType OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                    regular(0),
 | 
						|
                    fail-back(1)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether the replicaset is a regular replicaset or a fail-back replicaset. A regular replicaset is created on secondary site by the system when user enables replication of a volume on the primary site. A replicated-primary volume on the primary site can be demoted as a fail-back replicaset. A regular volume cannot be demoted as fail-back replicaset. Fail-back replicasets will have the volume configuration, ACL records, schedules etc before the demote, but that configuration will not be active. Fail-back replicasets can later be promoted as a replicated-primary volume when the volume is ready to resume its role."
 | 
						|
    DEFVAL         {regular}
 | 
						|
::=   { eqliscsiReplicaSetEntry 14 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiReplicaSetAccess OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                    no-access(0),
 | 
						|
                    read-only(1)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "By default, replicasets provide no-access to the user ie users cannot access the replicas or replicaset from an initiator. read-only-replicas provide read-only access to the replicas as well as the replicaset. Users must be able to connect to the replicas and replicaset using iscsi target names. Note that in-progress replica will not be available to read until the replication finishes."
 | 
						|
    DEFVAL          {no-access}
 | 
						|
::=   { eqliscsiReplicaSetEntry 15 }
 | 
						|
 | 
						|
eqliscsiReplicaSetFailbackReserve    OBJECT-TYPE
 | 
						|
   SYNTAX Unsigned32
 | 
						|
   MAX-ACCESS read-only
 | 
						|
   STATUS   current
 | 
						|
   DESCRIPTION 
 | 
						|
     " The value local repl reserve before demoting outbound-replicaset to failback-replicaset"
 | 
						|
::= { eqliscsiReplicaSetEntry 16 }
 | 
						|
 | 
						|
eqliscsiReplicaSetLSRPsvId  OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "If non-zero, the value represents the PsvId of last successful replication snapshot of this replicaset. This value will only be set when promoting a replicaset as failover volume.The value will be reset after failover volume is demoted as inbound replicaset and first replica is created."
 | 
						|
::= { eqliscsiReplicaSetEntry 17 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiReplicaSetOrigSize  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The value of this column represents the size of the recovery volume when it was promoted."
 | 
						|
::= { eqliscsiReplicaSetEntry 18 }
 | 
						|
 | 
						|
eqliscsiReplicaSetPrimaryMemberId  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The value of this column represents the eqliscsiLocalMemberId of the corresponding volume on the primary site."
 | 
						|
::= { eqliscsiReplicaSetEntry 19 }
 | 
						|
 | 
						|
eqliscsiReplicaSetPrimaryVolumeIndex  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The value of this column represents the eqliscsiVolumeIndex of the corresponding volume on the primary site."
 | 
						|
::= { eqliscsiReplicaSetEntry 20 }
 | 
						|
 | 
						|
eqliscsiReplicaSetPrimarySite  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The value of this column represents the eqliscsiVolumeReplSiteIndex of the corresponding volume on the primary site."
 | 
						|
::= { eqliscsiReplicaSetEntry 21 }
 | 
						|
 | 
						|
eqliscsiReplicaSetTemplateReplicated  OBJECT-TYPE
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies if the Template set has been successfully replicated"
 | 
						|
    DEFVAL          {false}
 | 
						|
    ::=   { eqliscsiReplicaSetEntry 22 }
 | 
						|
 | 
						|
eqliscsiReplicaSetSyncAdminStatus  OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      disabled(0),
 | 
						|
      enabled(1)
 | 
						|
      }
 | 
						|
   MAX-ACCESS       read-create
 | 
						|
   STATUS           current      
 | 
						|
   DESCRIPTION      "This field is there to let the secondary know when to bring the secondary replica volume online or offline.
 | 
						|
                     The replica volume will be brought online when syncRep is enabled and it will be brought offline when
 | 
						|
                     syncRep is disabled."
 | 
						|
   DEFVAL   { disabled }
 | 
						|
::= { eqliscsiReplicaSetEntry 23 }
 | 
						|
 | 
						|
eqliscsiReplicaSetThinClone  OBJECT-TYPE
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies if the Volume is a Thin Clone Volume."
 | 
						|
    DEFVAL          {false}
 | 
						|
    ::=   { eqliscsiReplicaSetEntry 24 }
 | 
						|
 | 
						|
eqliscsiReplicaSetRemotePsvId OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "A 16 byte, universally unique identifier for the remote
 | 
						|
                     replicated volume. The value for this object is specified
 | 
						|
                     by the array where the volume is located."  
 | 
						|
::= { eqliscsiReplicaSetEntry 25 }
 | 
						|
 | 
						|
--
 | 
						|
-- ReplicaSet status table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiReplicaSetStatusTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiReplicaSetStatusEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic replica set status Table.
 | 
						|
                     This table contains a list of replicasets with their size, status etc." 
 | 
						|
::= { eqliscsiTarget 19 }
 | 
						|
 | 
						|
eqliscsiReplicaSetStatusEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiReplicaSetStatusEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION " a row replicaset status table"
 | 
						|
    INDEX { eqliscsiLocalMemberId, eqliscsiVolumeIndex }
 | 
						|
::= { eqliscsiReplicaSetStatusTable 1 }
 | 
						|
      
 | 
						|
EqliscsiReplicaSetStatusEntry ::= SEQUENCE {
 | 
						|
   eqliscsiReplicaSetOperStatus  INTEGER,
 | 
						|
   eqliscsiReplicaSetSize        Unsigned32
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiReplicaSetOperStatus  OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER {
 | 
						|
      stopped(1),
 | 
						|
      inProgress(2),
 | 
						|
      waiting(3),
 | 
						|
      farEndDown(4),
 | 
						|
      authFailure(5)
 | 
						|
      }
 | 
						|
   MAX-ACCESS read-only  
 | 
						|
   STATUS   current
 | 
						|
   DESCRIPTION "The current operational status of the replication
 | 
						|
               process."
 | 
						|
::= { eqliscsiReplicaSetStatusEntry 1 }
 | 
						|
 | 
						|
eqliscsiReplicaSetSize  OBJECT-TYPE
 | 
						|
   SYNTAX Unsigned32
 | 
						|
   UNITS  "MB"
 | 
						|
   MAX-ACCESS read-only  
 | 
						|
   STATUS   current
 | 
						|
   DESCRIPTION "The size of the replicaset in MegaBytes.This includes the local replication reserve for failback replicasets."
 | 
						|
::= { eqliscsiReplicaSetStatusEntry 2 }
 | 
						|
 | 
						|
 | 
						|
-- 
 | 
						|
-- Replicant Site Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiReplicantSiteTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiReplicantSiteEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      The replicant site table contains all of the remote 
 | 
						|
      sites which have been given access to the local storage
 | 
						|
      pool for the purposes of creating replica sets."
 | 
						|
::= { eqliscsiTarget 20 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiReplicantSiteEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    INDEX           { eqliscsiReplicantSiteIndex }
 | 
						|
::= { eqliscsiReplicantSiteTable 1 }
 | 
						|
 | 
						|
EqliscsiReplicantSiteEntry ::= SEQUENCE {
 | 
						|
   eqliscsiReplicantSiteIndex                SiteIndex,
 | 
						|
   eqliscsiReplicantSiteRowStatus            RowStatus,
 | 
						|
   eqliscsiReplicantSiteName                 DisplayString,
 | 
						|
   eqliscsiReplicantSiteIpAddr               IpAddress,
 | 
						|
   eqliscsiReplicantSiteControlCredentials   RowPointer,
 | 
						|
   eqliscsiReplicantControlTargetIscsiName   OCTET STRING,
 | 
						|
   eqliscsiReplicantSiteSNMPContext          DisplayString,
 | 
						|
   eqliscsiReplicantSiteContact              DisplayString,
 | 
						|
   eqliscsiReplicantSiteEmail                DisplayString,
 | 
						|
   eqliscsiReplicantSitePhone                DisplayString,
 | 
						|
   eqliscsiReplicantSiteMobile               DisplayString,
 | 
						|
   eqliscsiReplicantSiteDescription          UTFString,
 | 
						|
   eqliscsiReplicantSiteSpaceAllocated       Unsigned32,
 | 
						|
   eqliscsiReplicantSiteSpaceUsed            Unsigned32,
 | 
						|
   eqliscsiReplicantSiteControlChannelStatus INTEGER,
 | 
						|
   eqliscsiReplicantSiteAdminStatus          INTEGER,
 | 
						|
   eqliscsiReplicantSiteTotalNumSnapshots    Unsigned32,
 | 
						|
   eqliscsiReplicantSiteStoragePoolIndex     Unsigned32,
 | 
						|
   eqliscsiReplicantSiteSpaceSubscribed      Unsigned32,
 | 
						|
   eqliscsiReplicantSiteInetAddrType         InetAddressType,
 | 
						|
   eqliscsiReplicantSiteInetAddr             InetAddress,
 | 
						|
   eqliscsiReplicantSiteUnmanagedSpace       Unsigned32,
 | 
						|
   eqliscsiReplicantSiteReplType                INTEGER
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiReplicantSiteIndex    OBJECT-TYPE
 | 
						|
   SYNTAX        SiteIndex 
 | 
						|
   MAX-ACCESS    not-accessible
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "A unique 32 bit identifier for this row"
 | 
						|
::= { eqliscsiReplicantSiteEntry 1 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteRowStatus OBJECT-TYPE           
 | 
						|
   SYNTAX RowStatus
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "The status of the row"
 | 
						|
::= { eqliscsiReplicantSiteEntry 2 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteName  OBJECT-TYPE              
 | 
						|
   SYNTAX        DisplayString(SIZE(1..64))
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "A concise, human readable string indentifier for the site,
 | 
						|
       for example: Boston HQ"
 | 
						|
::= { eqliscsiReplicantSiteEntry 3 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteIpAddr  OBJECT-TYPE            
 | 
						|
   SYNTAX IpAddress
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "EQL-SECONDARY-KEY
 | 
						|
       This field is deprecated and will be unsupported in the next release."
 | 
						|
::= { eqliscsiReplicantSiteEntry 4 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteControlCredentials  OBJECT-TYPE
 | 
						|
    SYNTAX          RowPointer
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION
 | 
						|
        "EQL-SECONDARY-KEY 
 | 
						|
         A pointer to the corresponding IPS-AUTH MIB 
 | 
						|
         ipsAuthCredChapAttributesEntry that contains the  
 | 
						|
         chap credentials which this PSA will use to 
 | 
						|
         authenticate itself to primary sites."
 | 
						|
    REFERENCE
 | 
						|
        "IPS-AUTH MIB"
 | 
						|
::= { eqliscsiReplicantSiteEntry 5 }
 | 
						|
 | 
						|
eqliscsiReplicantControlTargetIscsiName OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..223))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     The iSCSI name of the group-wide target that is 
 | 
						|
                     used to encapsulate replication control commands."
 | 
						|
::= { eqliscsiReplicantSiteEntry 6 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiReplicantSiteSNMPContext OBJECT-TYPE        
 | 
						|
   SYNTAX DisplayString
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "The SNMP context that will be used by applications at the
 | 
						|
       local site to browse MIBs on the remote site."
 | 
						|
::= { eqliscsiReplicantSiteEntry 7 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteContact OBJECT-TYPE
 | 
						|
    SYNTAX          DisplayString (SIZE(0..64))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
        "This field contains the full name of the replication site administrator."
 | 
						|
::= { eqliscsiReplicantSiteEntry 8 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteEmail OBJECT-TYPE
 | 
						|
    SYNTAX          DisplayString (SIZE(0..64))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
        "This field specifies the email address of the replication site administrator."
 | 
						|
::= { eqliscsiReplicantSiteEntry 9 }
 | 
						|
 | 
						|
eqliscsiReplicantSitePhone OBJECT-TYPE
 | 
						|
    SYNTAX          DisplayString (SIZE(0..32))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
        "This field specifies the phone number of the replication site administrator."
 | 
						|
::= { eqliscsiReplicantSiteEntry 10 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteMobile OBJECT-TYPE
 | 
						|
    SYNTAX          DisplayString (SIZE(0..32))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
        "This field specifies the cell phone number of the replication site administrator."
 | 
						|
::= { eqliscsiReplicantSiteEntry 11 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteDescription OBJECT-TYPE
 | 
						|
    SYNTAX          UTFString(SIZE(0..64))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     
 | 
						|
      "This field contains a detailed description of the site."
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  12 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteSpaceAllocated OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The total amount of pool space reserved for use by
 | 
						|
               the site. Replication may be set up as needed by the
 | 
						|
               administrators at the site as long as the total required 
 | 
						|
               reserve does not exceed this value."
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  13 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteSpaceUsed     OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The amount of reserve space already used by replicated volumes 
 | 
						|
               configured by the site administrator. This value may not exceed 
 | 
						|
               the corresponding value for eqliscsiReplicantSiteSpaceAllocated"
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  14 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteControlChannelStatus     OBJECT-TYPE
 | 
						|
   SYNTAX      INTEGER {
 | 
						|
                 control-target-not-configured(1),
 | 
						|
                 control-credentials-not-configured(2),
 | 
						|
                 authentication-failed(3),
 | 
						|
                 logged-in(4),
 | 
						|
                 logged-out(5),
 | 
						|
                 paused(6)
 | 
						|
 | 
						|
   }
 | 
						|
   MAX-ACCESS  read-only
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION " The current status of the control channel from primary site."
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  15 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteAdminStatus     OBJECT-TYPE
 | 
						|
   SYNTAX      INTEGER {
 | 
						|
               enabled(1),
 | 
						|
               paused(2),
 | 
						|
               nuke(3)
 | 
						|
   }
 | 
						|
   MAX-ACCESS  read-write
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION " When set to pause, all the replications coming from this primary site will be 
 | 
						|
                 temporarily suspended until set by the user to enabled.
 | 
						|
                 When set to nuke, all replicasets will be deleted.
 | 
						|
               "
 | 
						|
   DEFVAL     { enabled }
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  16 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteTotalNumSnapshots     OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION " the total number of snapshots in secondary site.
 | 
						|
               "
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  17 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteStoragePoolIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifying a storage pool."
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  18 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteSpaceSubscribed OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The total amount of pool space subscribed for use by
 | 
						|
               the site. Subscribed space is the advertised space for
 | 
						|
               thin provisioned volumes and it is the actual volume size
 | 
						|
               for regular volumes."
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  19 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteInetAddrType  OBJECT-TYPE            
 | 
						|
   SYNTAX InetAddressType
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "The well-known IP address of the group located at the
 | 
						|
       site. This will be the IP address to which iSCSI
 | 
						|
       replication traffic will be directed."
 | 
						|
::= { eqliscsiReplicantSiteEntry 20 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteInetAddr  OBJECT-TYPE            
 | 
						|
   SYNTAX InetAddress
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "The well-known IP address of the group located at the
 | 
						|
       site. This will be the IP address to which iSCSI
 | 
						|
       replication traffic will be directed."
 | 
						|
::= { eqliscsiReplicantSiteEntry 21 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteUnmanagedSpace OBJECT-TYPE
 | 
						|
   SYNTAX      Unsigned32
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "The total amount of pool space not managed by
 | 
						|
               the site. This includes the space used by the unmanaged
 | 
						|
               replica sets and recovery volumes."
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  22 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteReplType OBJECT-TYPE
 | 
						|
   SYNTAX      INTEGER{
 | 
						|
               normal(0),
 | 
						|
               external(1)
 | 
						|
   }
 | 
						|
   MAX-ACCESS  read-create
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION "This field represents the site type. 0 is normal aka regular repl site. 1 is external site that is not EQL."
 | 
						|
   DEFVAL     { normal }
 | 
						|
    ::=  { eqliscsiReplicantSiteEntry  23 }
 | 
						|
----------------------------------------------------------------------
 | 
						|
 | 
						|
-- Volume collection objects table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiVolCollectionObjectsTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolCollectionObjectsEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      This table maintains the list of volume objects in each collection.
 | 
						|
      "
 | 
						|
::= { eqliscsiTarget 21 }
 | 
						|
 | 
						|
eqliscsiVolCollectionObjectsEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolCollectionObjectsEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "An entry in the table."
 | 
						|
    INDEX           { eqliscsiVolCollectionIndex, eqliscsiLocalMemberId, eqliscsiVolumeIndex}
 | 
						|
::= { eqliscsiVolCollectionObjectsTable 1 }
 | 
						|
 | 
						|
EqliscsiVolCollectionObjectsEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolCollectionIndex               Unsigned32,
 | 
						|
   eqliscsiVolCollectionObjectRowStatus     RowStatus
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolCollectionIndex               OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32
 | 
						|
   MAX-ACCESS    not-accessible
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "A unique 32 bit identifier for this row"
 | 
						|
::= {  eqliscsiVolCollectionObjectsEntry  1 }
 | 
						|
 | 
						|
eqliscsiVolCollectionObjectRowStatus           OBJECT-TYPE
 | 
						|
   SYNTAX        RowStatus
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "Row status used to manage this row."
 | 
						|
::= {  eqliscsiVolCollectionObjectsEntry  2 }
 | 
						|
 | 
						|
----------------------------------------------------------------------
 | 
						|
 | 
						|
-- Volume collection table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiVolCollectionTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolCollectionEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      This table maintains the list of volume collections and the supported operations
 | 
						|
      on the collection."
 | 
						|
::= { eqliscsiTarget 22 }
 | 
						|
 | 
						|
eqliscsiVolCollectionEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolCollectionEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "An entry in the table."
 | 
						|
    INDEX           { eqliscsiVolCollectionIndex}
 | 
						|
::= { eqliscsiVolCollectionTable 1 }
 | 
						|
 | 
						|
EqliscsiVolCollectionEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolCollectionRowStatus           RowStatus,
 | 
						|
   eqliscsiVolCollectionName                OCTET STRING,
 | 
						|
   eqliscsiVolCollectionDescription         UTFString,
 | 
						|
   eqliscsiVolCollectionReplService         INTEGER,
 | 
						|
   eqliscsiVolCollectionSite                SiteIndexOrZero,
 | 
						|
   eqliscsiVolCollectionFlags               BITS
 | 
						|
}
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolCollectionRowStatus           OBJECT-TYPE
 | 
						|
   SYNTAX        RowStatus
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "Row status used to manage this row.
 | 
						|
       When deleteing a row from this table all the corresponding rows in snapcollection table
 | 
						|
       must be reset to zero vol collection index"
 | 
						|
::= {  eqliscsiVolCollectionEntry  1 }
 | 
						|
 | 
						|
eqliscsiVolCollectionName OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..64))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies a user friendly name for this collection.
 | 
						|
                     The name must be unique within a group.
 | 
						|
                     The name must not contain spaces or special characters.
 | 
						|
                     The name can be up to 64 characters in length. There is no default."
 | 
						|
    ::=  {  eqliscsiVolCollectionEntry 2 }  
 | 
						|
 | 
						|
eqliscsiVolCollectionDescription OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a descriptive string that provides details about this collection.
 | 
						|
                     The description can be up to 128 characters."  
 | 
						|
    DEFVAL          { "" }
 | 
						|
    ::=  {  eqliscsiVolCollectionEntry 3 } 
 | 
						|
          
 | 
						|
eqliscsiVolCollectionReplService OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                    none(0),
 | 
						|
                    replica-site(1),
 | 
						|
                    replicated-primary(2)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the replication service on the volume collection. 
 | 
						|
                     If this volume collection is created for replication of a volume collection at partner site, 
 | 
						|
                     then the value is set to replica-site.
 | 
						|
                     If this volume collection is enabled for replication to a partner site, the the value is
 | 
						|
                     set to replicated-primary."
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=  {  eqliscsiVolCollectionEntry 4 } 
 | 
						|
 | 
						|
eqliscsiVolCollectionSite OBJECT-TYPE      
 | 
						|
    SYNTAX          SiteIndexOrZero
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the partner to which this collection belongs. The value 
 | 
						|
                     will match with eqliscsiVolumeReplSiteIndex if this collection belongs to a partner.
 | 
						|
                     Otherwise the value is set to zero. The value will be non-zero only when 
 | 
						|
                     eqliscsiVolCollectionReplService is replica-site."
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=  {  eqliscsiVolCollectionEntry 5 } 
 | 
						|
 | 
						|
eqliscsiVolCollectionFlags OBJECT-TYPE
 | 
						|
    SYNTAX          BITS {
 | 
						|
                    isPoolSyncReplicated(0), -- is the volume collection a sync rep collection?
 | 
						|
                    flag1(1),
 | 
						|
                    flag2(2),
 | 
						|
                    flag3(3),
 | 
						|
                    flag4(4),
 | 
						|
                    flag5(5),
 | 
						|
                    flag6(6),
 | 
						|
                    flag7(7),
 | 
						|
                    flag8(8),
 | 
						|
                    flag9(9),
 | 
						|
                    flag10(10),
 | 
						|
                    flag11(11),
 | 
						|
                    flag12(12),
 | 
						|
                    flag13(13),
 | 
						|
                    flag14(14),
 | 
						|
                    flag15(15),
 | 
						|
                    flag16(16),
 | 
						|
                    flag17(17),
 | 
						|
                    flag18(18),
 | 
						|
                    flag19(19),
 | 
						|
                    flag20(20),
 | 
						|
                    flag21(21),
 | 
						|
                    flag22(22),
 | 
						|
                    flag23(23),
 | 
						|
                    flag24(24),
 | 
						|
                    flag25(25),
 | 
						|
                    flag26(26),
 | 
						|
                    flag27(27),
 | 
						|
                    flag28(28),
 | 
						|
                    flag29(29),
 | 
						|
                    flag30(30),
 | 
						|
                    flag31(31)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This fields defines the common place holder for volume collection operational flags.  The flags must be of type
 | 
						|
                    enable(1) or disable(0), and the default will always be disable(0)."
 | 
						|
    DEFVAL          { {} }
 | 
						|
    ::= { eqliscsiVolCollectionEntry 6 }
 | 
						|
 | 
						|
----------------------------------------------------------------------
 | 
						|
-- Snapshot collection objects table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiSnapCollectionObjectsTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiSnapCollectionObjectsEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      This table maintains the list of snapshot objects in each collection.
 | 
						|
      "
 | 
						|
::= { eqliscsiTarget 23 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionObjectsEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiSnapCollectionObjectsEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "An entry in the table."
 | 
						|
    INDEX           { eqliscsiSnapCollectionIndex, eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiSnapshotIndex }
 | 
						|
::= { eqliscsiSnapCollectionObjectsTable 1 }
 | 
						|
 | 
						|
EqliscsiSnapCollectionObjectsEntry ::= SEQUENCE {
 | 
						|
   eqliscsiSnapCollectionIndex               Unsigned32,
 | 
						|
   eqliscsiSnapCollectionObjectRowStatus           RowStatus
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiSnapCollectionIndex               OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32
 | 
						|
   MAX-ACCESS    not-accessible
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "A unique 32 bit identifier for this row"
 | 
						|
::= {  eqliscsiSnapCollectionObjectsEntry  1 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionObjectRowStatus           OBJECT-TYPE
 | 
						|
   SYNTAX        RowStatus
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "Row status used to manage this row. Rowstatus is set to notInService by the subsystem
 | 
						|
       when the actual snapshot represented by this row is deleted. The row from this table
 | 
						|
       will be automatically deleted when the corresponding volume is deleted (or) #when
 | 
						|
       all rows of this group have the status notInService# (or) when the corresponding row is deleted
 | 
						|
       from snapcollection table."
 | 
						|
::= {  eqliscsiSnapCollectionObjectsEntry  2 }
 | 
						|
 | 
						|
----------------------------------------------------------------------
 | 
						|
 | 
						|
-- Snapshot collection table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiSnapCollectionTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiSnapCollectionEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      This table maintains the list of snapshot collections and the supported operations
 | 
						|
      on the collection.
 | 
						|
      TimeoutCreate:60 TimeoutDelete:60"  
 | 
						|
::= { eqliscsiTarget 24 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiSnapCollectionEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "An entry in the table."
 | 
						|
    INDEX           { eqliscsiSnapCollectionIndex}
 | 
						|
::= { eqliscsiSnapCollectionTable 1 }
 | 
						|
 | 
						|
EqliscsiSnapCollectionEntry ::= SEQUENCE {
 | 
						|
   eqliscsiSnapCollectionRowStatus           RowStatus,
 | 
						|
   eqliscsiSnapCollectionName                OCTET STRING,
 | 
						|
   eqliscsiSnapCollectionDescription         UTFString,
 | 
						|
   eqliscsiSnapCollectionTimestamp           Counter32,
 | 
						|
   eqliscsiSnapCollectionNoofSnaps           Unsigned32,
 | 
						|
   eqliscsiSnapCollectionVolIndex            Unsigned32,
 | 
						|
   eqliscsiSnapCollectionVSS                 INTEGER,
 | 
						|
   eqliscsiSnapCollectionScheduleIndex       Integer32,
 | 
						|
   eqliscsiSnapCollectionReplicated          SiteIndexOrZero,
 | 
						|
   eqliscsiSnapCollectionType                INTEGER,
 | 
						|
   eqliscsiSnapCollectionSite                SiteIndexOrZero
 | 
						|
}
 | 
						|
 | 
						|
 | 
						|
eqliscsiSnapCollectionRowStatus           OBJECT-TYPE
 | 
						|
   SYNTAX        RowStatus
 | 
						|
   MAX-ACCESS    read-create
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "Row status used to manage this row."
 | 
						|
::= {  eqliscsiSnapCollectionEntry  1 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionName OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (1..128))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies a user friendly name for this collection.
 | 
						|
                     The name must not contain spaces or special characters.
 | 
						|
                     The name can be up to 64 characters in length. There is no default."
 | 
						|
    ::=  {  eqliscsiSnapCollectionEntry 2 }  
 | 
						|
 | 
						|
eqliscsiSnapCollectionDescription OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a descriptive string that provides details about this collection.
 | 
						|
                     The description can be up to 128 characters."  
 | 
						|
    DEFVAL          { "" }
 | 
						|
    ::=  {  eqliscsiSnapCollectionEntry 3 } 
 | 
						|
          
 | 
						|
eqliscsiSnapCollectionTimestamp OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies the creation time for snapshot.
 | 
						|
                     Time is represented as the time in seconds since 00:00:00 UTC, 1970-01-01." 
 | 
						|
    ::= {   eqliscsiSnapCollectionEntry 4 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionNoofSnaps OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     " No of snapshots in this collection at the time of creation."
 | 
						|
    ::= {   eqliscsiSnapCollectionEntry 5 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionVolIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32  
 | 
						|
    MAX-ACCESS      read-write     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
                    " EQL-SECONDARY-KEY
 | 
						|
                    The index of the volcollection that created this group.  
 | 
						|
                      When the volcollection is deleted, this value will be set to zero."
 | 
						|
    ::= {   eqliscsiSnapCollectionEntry 6 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionVSS OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER{
 | 
						|
                    regular(0),
 | 
						|
                    vss(1)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-write     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     " If this snap collection is created using vss."
 | 
						|
    DEFVAL          {0}
 | 
						|
    ::= {   eqliscsiSnapCollectionEntry 7 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionScheduleIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
        " EQL-SECONDARY-KEY
 | 
						|
          This field specifies the index of the snapshot policy if it is created
 | 
						|
          by a snapshotpolicy, otherwise it will be set to zero. If the policy
 | 
						|
          is deleted after the snapshot is created, this will be reset back to 
 | 
						|
          zero by the subsystem."
 | 
						|
    ::= {   eqliscsiSnapCollectionEntry 8 }
 | 
						|
   
 | 
						|
eqliscsiSnapCollectionReplicated    OBJECT-TYPE
 | 
						|
   SYNTAX            SiteIndexOrZero
 | 
						|
   MAX-ACCESS        read-create
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "When a row is created with this object set to a non zero value, 
 | 
						|
                     , the snapcollection will be queued to be replicated to the
 | 
						|
                     remote location indicated by the corresponing value 
 | 
						|
                     of site index in the site table 
 | 
						|
 | 
						|
                     The value for this object cannot be changed to zero once the snapcollection 
 | 
						|
                     is created."
 | 
						|
   ::=   { eqliscsiSnapCollectionEntry 9}
 | 
						|
          
 | 
						|
eqliscsiSnapCollectionType  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        regular(0),
 | 
						|
                        replica-site(1)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "Specifies the type of snapcollection."
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=   {eqliscsiSnapCollectionEntry 10 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionSite    OBJECT-TYPE
 | 
						|
   SYNTAX            SiteIndexOrZero
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "If non-zero, this value represents the partner who created this snap collection ie eqliscsiReplicantSiteIndex.
 | 
						|
                      This collection belongs to that partner not to our group."
 | 
						|
   DEFVAL            {0}
 | 
						|
   ::=   { eqliscsiSnapCollectionEntry 11}
 | 
						|
 | 
						|
----------------------------------------------------------------------
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyTable OBJECT-TYPE      
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiSnapCollectionPolicyEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Storage SnapSnot Policy Table."  
 | 
						|
    ::=  {  eqliscsiTarget 25 }    
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiSnapCollectionPolicyEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing snapshot scheduling policy 
 | 
						|
                     information.The policy determines when to create 
 | 
						|
                     snapshot(s) of a volume collection."
 | 
						|
    INDEX           { eqliscsiVolCollectionIndex, eqliscsiSnapCollectionPolicyIndex }    
 | 
						|
::=    { eqliscsiSnapCollectionPolicyTable 1 }
 | 
						|
 | 
						|
    
 | 
						|
EqliscsiSnapCollectionPolicyEntry ::= 
 | 
						|
    SEQUENCE {     
 | 
						|
        eqliscsiSnapCollectionPolicyIndex               Integer32,  
 | 
						|
        eqliscsiSnapCollectionPolicyRowStatus           RowStatus,
 | 
						|
        eqliscsiSnapCollectionPolicyName                OCTET STRING,
 | 
						|
        eqliscsiSnapCollectionPolicyAccessType          INTEGER, 
 | 
						|
        eqliscsiSnapCollectionPolicyStatus              INTEGER, 
 | 
						|
        eqliscsiSnapCollectionPolicyMaxKeep             Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyType                INTEGER,
 | 
						|
        eqliscsiSnapCollectionPolicyRepeatFactor        Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyStartTime           Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyEndTime             Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyTimeFrequency       Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyStartDate           Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyEndDate             Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyWeekMask            Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyMonthMask           Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyNextCreate          Counter32,
 | 
						|
        eqliscsiSnapCollectionPolicyOccurence           Integer32,
 | 
						|
        eqliscsiSnapCollectionPolicyReplication         SiteIndexOrZero,
 | 
						|
        eqliscsiSnapCollectionPolicyAdminStatus         INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "This value uniquely identifies the snapshot policies for a volume collection."
 | 
						|
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 1 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "This value is used to manage the conceptual row."
 | 
						|
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 2 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyName  OBJECT-TYPE   
 | 
						|
    SYNTAX          OCTET STRING (SIZE (1..64))    
 | 
						|
    MAX-ACCESS      read-create     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "This value specifies user friendly name for the policy. 
 | 
						|
           It is unique within the context of a volume collection. Spaces are not allowed."
 | 
						|
                     
 | 
						|
    ::=   { eqliscsiSnapCollectionPolicyEntry 3}
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyAccessType  OBJECT-TYPE   
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                      read-write (1),
 | 
						|
                      read-only  (2)
 | 
						|
    }   
 | 
						|
    MAX-ACCESS      read-create       
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "Snapshots created using this policy will have accesstype same as the
 | 
						|
           value of this object." 
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 4 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyStatus  OBJECT-TYPE   
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                      online  (1),
 | 
						|
                      offline (2) 
 | 
						|
    }   
 | 
						|
    MAX-ACCESS      read-create       
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "Snapshots created using this policy will have status same as the
 | 
						|
           value of this object."
 | 
						|
 | 
						|
    DEFVAL          { offline }
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 5 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyMaxKeep  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (1..2147483647)
 | 
						|
    UNITS           "snapshots"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this object determines the maximum no of snapshots
 | 
						|
           created by this policy that can exist at a given time. When number
 | 
						|
           of snapshots created by this policy reaches this value, for creating
 | 
						|
           a new snapshot oldest snapshot created using this policy will be 
 | 
						|
           deleted.
 | 
						|
           In a set operation, if the new value of this object is less than
 | 
						|
           the old value, required number of oldest snapshots created by this
 | 
						|
           policy will be deleted. 
 | 
						|
          "
 | 
						|
    DEFVAL          { 10 }
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 6 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyType  OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                      once    (1),
 | 
						|
                      daily   (2),
 | 
						|
                      weekly  (3),
 | 
						|
                      monthly (4),
 | 
						|
                      hourly  (5)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this object determines the basic type of this policy.
 | 
						|
           Except when set to once, the effective repetition period of the 
 | 
						|
           policy is determined using the value of this object along with
 | 
						|
           the value of eqliscsiSnapCollectionPolicyRepeatFactor. 
 | 
						|
           (See description of eqliscsiSnapCollectionPolicyRepeatFactor 
 | 
						|
            for more information.)
 | 
						|
          "
 | 
						|
 | 
						|
    DEFVAL          { daily }
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 7 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyRepeatFactor  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (1..2147483647)
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "The value of this object along with eqliscsiSnapCollectionPolicyType
 | 
						|
           determines the effective repetition interval for this policy.
 | 
						|
           The valid values are
 | 
						|
 | 
						|
              PolicyType            RepeatFactor  
 | 
						|
                 once                    1
 | 
						|
                 hourly                  1
 | 
						|
                 daily                  1-2147483647
 | 
						|
                 weekly                 1-2147483647
 | 
						|
                 monthly                1-2147483647
 | 
						|
 | 
						|
           If the policy type is daily and the value of this object is 2,
 | 
						|
           snapshots will be taken once in every 2 days.
 | 
						|
          "
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 8 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyStartTime  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..1439)
 | 
						|
    UNITS           "minutes"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " 
 | 
						|
            The value of this object represents the time to start creating
 | 
						|
            snapshot(s) within a day expressed as number of minutes 
 | 
						|
            from 12:00AM. The maximum value for this column is 24*60-1 which 
 | 
						|
            represents 11:59PM.
 | 
						|
          "
 | 
						|
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 9 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyEndTime  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..1439)
 | 
						|
    UNITS           "minutes"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION      
 | 
						|
          " 
 | 
						|
            The value of this object represents the time to stop creating
 | 
						|
            snapshot(s) within a day expressed as number of minutes 
 | 
						|
            from 12:00AM. The maximum value for this column is 24*60-1 which 
 | 
						|
            represents 11:59PM. 
 | 
						|
 
 | 
						|
            If eqliscsiSnapCollectionPolicyType is once or hourly, the value of
 | 
						|
            this column doesn't have any significance. 
 | 
						|
 | 
						|
            If the value of this column is greater than start time, it 
 | 
						|
            represents end-time on the same day as start time. If the value 
 | 
						|
            is less than or equal to start time, it represents end-time on the
 | 
						|
            next day of start time.
 | 
						|
            This value doesnt have significance when frequency is set to zero.
 | 
						|
            Endtime is exclusive when calculating no of snapshots.
 | 
						|
 | 
						|
            Example:
 | 
						|
                     StartTime      EndTime    Frequency    NoofSnapshots
 | 
						|
                       1320(10pm)   1380(11pm)    30mins        2
 | 
						|
                       1320(10pm)   240(4am)      60mins        6
 | 
						|
                       1320(10pm)   1320(10pm)    60mins        24
 | 
						|
                       1320(10pm)   1319(9:59pm)  60mins        24
 | 
						|
                       1320(10pm)     -            0mins         1
 | 
						|
          "
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 10 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyTimeFrequency  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..1439)
 | 
						|
    UNITS           "minutes"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "The value of this object determines how frequent snapshots must be 
 | 
						|
           taken between start time and end time. This value doesn't have 
 | 
						|
           significance when policy type is set to once. For other policytypes,
 | 
						|
           the value of end time is exclusive. 
 | 
						|
           For example if starttime is 180 (3:00AM) and endtime is 
 | 
						|
           240(4:00AM), when frequency is set to 30, snapshots will be 
 | 
						|
           created at 3:00AM, 3:30AM.
 | 
						|
           If the value is zero, it represents invalid frequency and
 | 
						|
           in such case, end time doesnt have significance.
 | 
						|
          "
 | 
						|
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 11 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyStartDate  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..2147483647)
 | 
						|
    UNITS           "days"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " The value of this object determines the date from which the policy
 | 
						|
            will be active. By default, this is the policy creation date.
 | 
						|
            The value is expressed as number of days since epoch.
 | 
						|
          "  
 | 
						|
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 12 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyEndDate  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 (0..2147483647)
 | 
						|
    UNITS           "days"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " The value of this object determines the date after which the policy
 | 
						|
            will be inactive.It doesnt have significance when policy type
 | 
						|
            is once. Default value is the mamixum value allowed. When set to maximum
 | 
						|
            value, the policy will be active until it gets deleted.
 | 
						|
            The value is expressed as number of days since epoch.
 | 
						|
          "  
 | 
						|
    DEFVAL          { 2147483647 }
 | 
						|
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 13 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyWeekMask  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " The value of this column is significant only if policytype is
 | 
						|
            set to weekly or monthly.  When the value is 0x7fffffff, it 
 | 
						|
            represents a special meaning to the value of occurence. See
 | 
						|
            the description for occurence below.
 | 
						|
            The LSB to LSB+6 bits of the mask are significant.
 | 
						|
            Each bit represents a day in the week with LSB being Mon and LSB+6
 | 
						|
            being Sun.
 | 
						|
            If mask is 0x00000041 - snapshots will be created on Monday and 
 | 
						|
            Sunday. If mask is 0x0000007f - snapshots will be created on all
 | 
						|
            weekdays which is effectively a daily policy. If mask is 0x0000001f,
 | 
						|
            it represents week days.If mask is 0x00000060, it represents
 | 
						|
            weekend days.
 | 
						|
          "
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 14 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyMonthMask  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " The value of this column is currently not being used."
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 15 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyNextCreate  OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32 
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           EQL-SECONDARY-KEY 
 | 
						|
           The value of this column represents number of seconds since epoch
 | 
						|
           at which the next snapshot by this policy is going to be created.
 | 
						|
          "
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 16 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyOccurence  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this column is significant only if the policy type is
 | 
						|
           set to monthly.
 | 
						|
 | 
						|
           If weekmask is set to 0x7fffffff, the value of this column represents
 | 
						|
           the occurence of a day with in a month. Example:If the value of this 
 | 
						|
           column is 5, it represents 5th day of the month. When the week mask
 | 
						|
           is set to a value other than 0x7fffffff, the value of this column
 | 
						|
           defines the occurence of a day as defined by weekmask. Example: When
 | 
						|
            weekmask is set to 0x00000001 (Monday) and value of this column
 | 
						|
           represents the following.
 | 
						|
 
 | 
						|
                        Value            Meaning
 | 
						|
 | 
						|
                          0x1               First monday of the month
 | 
						|
                          0x2               Second monday of the month
 | 
						|
                          0x3               Third monday of the month
 | 
						|
                          0x4               Fourth monday of the month
 | 
						|
                          0x7fffffff        Last monday of the month
 | 
						|
          "
 | 
						|
 | 
						|
    DEFVAL  {0}
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyEntry 17 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyReplication    OBJECT-TYPE
 | 
						|
   SYNTAX            SiteIndexOrZero
 | 
						|
   MAX-ACCESS        read-create
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "When a row is created with this object set to a non-zero value, and
 | 
						|
                     a replication relationship has been configured for all volumes in the 
 | 
						|
                     volume collection, the snapshots created will be queued to be replicated to the
 | 
						|
                     remote location as defined by the corresponding entry in the site table.
 | 
						|
                     The value for this object cannot be changed once the schedule
 | 
						|
                     is created. All the volumes in this collection must be replicating to the
 | 
						|
                     same partner."
 | 
						|
   ::=   { eqliscsiSnapCollectionPolicyEntry 18 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyAdminStatus    OBJECT-TYPE
 | 
						|
   SYNTAX            INTEGER {
 | 
						|
                        enable(0),
 | 
						|
                        disable(1)
 | 
						|
   }
 | 
						|
   MAX-ACCESS        read-create
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "When disabled, the schedule will stop creating snap collections until reenabled."
 | 
						|
   DEFVAL            {enable}
 | 
						|
   ::=   { eqliscsiSnapCollectionPolicyEntry 19 }
 | 
						|
 | 
						|
----------------------------------------------------
 | 
						|
eqliscsiVolCollectionStatusTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolCollectionStatusEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Dynamic
 | 
						|
      This table maintains the dynamic values related to volume collection like number of snapcollection
 | 
						|
      in a volume collection."
 | 
						|
::= { eqliscsiTarget 26 }
 | 
						|
 | 
						|
eqliscsiVolCollectionStatusEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolCollectionStatusEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "An entry in the table."
 | 
						|
    INDEX           { eqliscsiVolCollectionIndex}
 | 
						|
::= { eqliscsiVolCollectionStatusTable 1 }
 | 
						|
 | 
						|
EqliscsiVolCollectionStatusEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiNoOfSnapCollections          Unsigned32
 | 
						|
        }
 | 
						|
eqliscsiNoOfSnapCollections OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the total number of snap collections in a volume collection.
 | 
						|
                     number of rows in eqliscsiSnapCollectionTable that belong to this volume set."
 | 
						|
    DEFVAL          {0}
 | 
						|
    ::=  { eqliscsiVolCollectionStatusEntry  1 }
 | 
						|
-----------------------------------------------
 | 
						|
eqliscsiSnapCollectionAdminGroup OBJECT IDENTIFIER ::= { eqliscsiTarget 27 }
 | 
						|
 | 
						|
eqliscsiLastSnapCollectionIndex OBJECT-TYPE
 | 
						|
   SYNTAX            Unsigned32
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "EqualLogic-Dynamic
 | 
						|
                     This object represents the highest numeric index that 
 | 
						|
                     any row in the eqliscsiSnapCollectionTable has. An application 
 | 
						|
                     can use this value to determine an index with whico 
 | 
						|
                     create an additional row in that table without scanning
 | 
						|
                     the entire table for a usable index."
 | 
						|
   ::= { eqliscsiSnapCollectionAdminGroup 1 }
 | 
						|
 | 
						|
--    Remote ReplicaCollectionObjects Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiRemoteReplicaCollectionObjectsTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiRemoteReplicaCollectionObjectsEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent"
 | 
						|
::= { eqliscsiTarget 28 }
 | 
						|
 | 
						|
eqliscsiRemoteReplicaCollectionObjectsEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiRemoteReplicaCollectionObjectsEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    INDEX           { eqliscsiVolumeReplSiteIndex, eqliscsiRemoteSnapCollectionIndex, eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiRemoteVolumeIndex, eqliscsiRemoteSnapIndex }
 | 
						|
::= { eqliscsiRemoteReplicaCollectionObjectsTable 1 }
 | 
						|
 | 
						|
EqliscsiRemoteReplicaCollectionObjectsEntry ::= SEQUENCE {
 | 
						|
   eqliscsiRemoteSnapCollectionIndex          Unsigned32,
 | 
						|
   eqliscsiRemoteReplCollectionObjRowStatus   RowStatus
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiRemoteSnapCollectionIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing a snapshot collection on remote site.
 | 
						|
                     The index is the same as the value for eqliscsiSnapCollectionIndex on
 | 
						|
                     the remote site."  
 | 
						|
::= { eqliscsiRemoteReplicaCollectionObjectsEntry 1 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiRemoteReplCollectionObjRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus     
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
      "Row status used to manage this row. Rowstatus is set to notInService by the subsystem
 | 
						|
       when the actual replica represented by this row is deleted. The row from this table
 | 
						|
       will be automatically deleted when
 | 
						|
       all rows that belong to a collection have the status notInService# (or) 
 | 
						|
       when the corresponding row is deleted from remotereplicacollection table."
 | 
						|
::= { eqliscsiRemoteReplicaCollectionObjectsEntry 2 }
 | 
						|
 | 
						|
--    Remote ReplicaCollection Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiRemoteReplicaCollectionTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiRemoteReplicaCollectionEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent"
 | 
						|
::= { eqliscsiTarget 29 }
 | 
						|
 | 
						|
eqliscsiRemoteReplicaCollectionEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiRemoteReplicaCollectionEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    INDEX           { eqliscsiVolumeReplSiteIndex, eqliscsiRemoteSnapCollectionIndex }
 | 
						|
::= { eqliscsiRemoteReplicaCollectionTable 1 }
 | 
						|
 | 
						|
EqliscsiRemoteReplicaCollectionEntry ::= SEQUENCE {
 | 
						|
   eqliscsiRemoteReplCollectionName        OCTET STRING,
 | 
						|
   eqliscsiRemoteReplCollectionAdminStatus INTEGER,
 | 
						|
   eqliscsiRemoteReplCollectionTimeStamp   Counter32,
 | 
						|
   eqliscsiRemoteReplCollectionVolIndex    Unsigned32,
 | 
						|
   eqliscsiRemoteReplCollectionSchedIndex  Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiRemoteReplCollectionName  OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the friendly name used to identify the replica Collection on remote site.
 | 
						|
                     The name is auto-generated. The name is unique between replica collections of a single
 | 
						|
                     volumecollection at a particular site."
 | 
						|
    ::= {   eqliscsiRemoteReplicaCollectionEntry 1 }  
 | 
						|
 | 
						|
eqliscsiRemoteReplCollectionAdminStatus OBJECT-TYPE
 | 
						|
   SYNTAX        INTEGER {
 | 
						|
                 none(0),
 | 
						|
                 delete(1)
 | 
						|
   }
 | 
						|
   MAX-ACCESS    read-write
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "Manage the replica status. The row will be deleted from this table if value is set to delete."
 | 
						|
::= { eqliscsiRemoteReplicaCollectionEntry 2 }
 | 
						|
 | 
						|
eqliscsiRemoteReplCollectionTimeStamp OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "
 | 
						|
                     This field specifies the creation time of the replica collection.
 | 
						|
                     Time is represented as the time in seconds since 00:00:00 UTC, 1970-01-01.
 | 
						|
                    " 
 | 
						|
    ::= {   eqliscsiRemoteReplicaCollectionEntry 3 }
 | 
						|
eqliscsiRemoteReplCollectionVolIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
                    " EQL-SECONDARY-KEY
 | 
						|
                      This field specifies the index of the vol collection on the primary site used to create 
 | 
						|
                      this snap collection  
 | 
						|
                      was created on remote site. The value will be zero if the volcollection
 | 
						|
                     doesn't exist anymore.
 | 
						|
                     The index is the same as the the value for eqliscsiVolCollectionIndex
 | 
						|
                     for the repl collection."  
 | 
						|
::= { eqliscsiRemoteReplicaCollectionEntry 4 }
 | 
						|
 | 
						|
eqliscsiRemoteReplCollectionSchedIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
                    " EQL-SECONDARY-KEY
 | 
						|
                     This field specifies the index of the schedule on the primary site that initiated
 | 
						|
                     create replica collection operation. This will be set to zero when schedule is deleted.
 | 
						|
                     "  
 | 
						|
::= { eqliscsiRemoteReplicaCollectionEntry 5 }
 | 
						|
----------------------------------
 | 
						|
-- VolumeCollection Replication Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiVolColReplicationTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolColReplicationEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent"
 | 
						|
::= { eqliscsiTarget 30 }
 | 
						|
 | 
						|
eqliscsiVolColReplicationEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolColReplicationEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    INDEX           { eqliscsiVolCollectionIndex, eqliscsiVolumeReplSiteIndex }
 | 
						|
::= { eqliscsiVolColReplicationTable 1 }
 | 
						|
 | 
						|
EqliscsiVolColReplicationEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolColReplRowStatus            RowStatus,
 | 
						|
   eqliscsiVolColReplAdminStatus          INTEGER,
 | 
						|
   eqliscsiVolColReplDeletionPolicy       INTEGER,
 | 
						|
   eqliscsiVolColReplRemoteCollectionId   Unsigned32
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolColReplRowStatus   OBJECT-TYPE     
 | 
						|
    SYNTAX          RowStatus
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
   DESCRIPTION
 | 
						|
      "The status of the row"
 | 
						|
::= { eqliscsiVolColReplicationEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolColReplAdminStatus  OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER{
 | 
						|
      enabled(1),
 | 
						|
      disabled(2)
 | 
						|
      }
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
   DESCRIPTION "This object is used to request a change 
 | 
						|
               in the current admin status of the replication
 | 
						|
               process. When read, it represents the current 
 | 
						|
               admin status.
 | 
						|
               If disabled, the replication can NEVER be restarted again."
 | 
						|
   DEFVAL   { enabled }
 | 
						|
::= { eqliscsiVolColReplicationEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolColReplDeletionPolicy     OBJECT-TYPE 
 | 
						|
   SYNTAX INTEGER { 
 | 
						|
      local-only(1),
 | 
						|
      remote(2)
 | 
						|
   }
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
   DESCRIPTION "The depth of deletion desired when replication at the local 
 | 
						|
                array is disabled for an associated primary volume collection. The choices are 
 | 
						|
                as follows:
 | 
						|
                  local_only: Only the local references to the remote replica set collection 
 | 
						|
                              will be removed. The remote replica set collection will remain 
 | 
						|
                              intact and will need to be managed at the remote site.
 | 
						|
                  remote: The remote replica set collection will be deleted. This will destroy 
 | 
						|
                          all of the remote data.
 | 
						|
 | 
						|
               Note that setting the value to 'remote' will cause the delete operation
 | 
						|
               to fail if there is no connectivity to the remote site. If the deletion needs to 
 | 
						|
               proceed regardless of the state of the remote site, the local_only policy shoud be
 | 
						|
               used"
 | 
						|
   DEFVAL { remote }
 | 
						|
::= { eqliscsiVolColReplicationEntry 3 }   
 | 
						|
 | 
						|
eqliscsiVolColReplRemoteCollectionId     OBJECT-TYPE 
 | 
						|
   SYNTAX          Unsigned32 
 | 
						|
   MAX-ACCESS      read-only      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     " An identifier for the remote replica volume collection. The value is same as  eqliscsiVolCollectionIndex
 | 
						|
                    of the collection created at partner site."
 | 
						|
::= { eqliscsiVolColReplicationEntry 4 }   
 | 
						|
 | 
						|
----------------------------------
 | 
						|
-- VolumeCollection Replication Status Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiVolColReplStatusTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolColReplStatusEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Dynamic"
 | 
						|
::= { eqliscsiTarget 31 }
 | 
						|
 | 
						|
eqliscsiVolColReplStatusEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolColReplStatusEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      " Statistics related to volume collection replication configuration."
 | 
						|
    AUGMENTS        { eqliscsiVolColReplicationEntry }
 | 
						|
::= { eqliscsiVolColReplStatusTable 1 }
 | 
						|
 | 
						|
EqliscsiVolColReplStatusEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolColReplStatusNumReplicas          Unsigned32
 | 
						|
}
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolColReplStatusNumReplicas   OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "The number of replica collections present at the replica site
 | 
						|
                    for this volume collection.
 | 
						|
                    The value of this object matches with number of rows in eqliscsiRemoteReplicaCollectionTable
 | 
						|
                    that correspond to this volume replication entry."
 | 
						|
   DEFVAL          { 0 }
 | 
						|
::= { eqliscsiVolColReplStatusEntry 1 }
 | 
						|
 | 
						|
--*************************************************************************
 | 
						|
 | 
						|
eqlVolumePoolPlacementTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqlVolumePoolPlacementEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Volume Storage Pool Placement Table.
 | 
						|
                     This table contains a list of volume placements in a pool." 
 | 
						|
    ::=    { eqliscsiTarget 32 }
 | 
						|
 | 
						|
eqlVolumePoolPlacementEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqlVolumePoolPlacementEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing a placement of a volume in a pool."
 | 
						|
    INDEX           { eqlGroupId, eqlStoragePoolIndex, eqliscsiLocalMemberId, eqliscsiVolumeIndex }    
 | 
						|
    ::=   { eqlVolumePoolPlacementTable 1 }     
 | 
						|
 | 
						|
EqlVolumePoolPlacementEntry ::= 
 | 
						|
    SEQUENCE {
 | 
						|
        eqlVolumePoolPlacementiscsiVolumePsvId    OCTET STRING
 | 
						|
    }
 | 
						|
 | 
						|
eqlVolumePoolPlacementiscsiVolumePsvId OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))     
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field is for internal use only."  
 | 
						|
    ::=  { eqlVolumePoolPlacementEntry 1 }
 | 
						|
 | 
						|
 | 
						|
--- Volume Replication Statistics Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiVolReplStatisticsTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolReplStatisticsEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent"
 | 
						|
::= { eqliscsiTarget 33 }
 | 
						|
 | 
						|
eqliscsiVolReplStatisticsEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolReplStatisticsEntry 
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeReplSiteIndex , eqliscsiReplSampleIndex}
 | 
						|
::= { eqliscsiVolReplStatisticsTable 1 }
 | 
						|
 | 
						|
EqliscsiVolReplStatisticsEntry ::= SEQUENCE {
 | 
						|
   eqliscsiReplSampleIndex         Unsigned32,
 | 
						|
   eqliscsiReplStartTime           Counter32,
 | 
						|
   eqliscsiReplEndTime             Counter32,
 | 
						|
   eqliscsiReplTxData              Counter64,
 | 
						|
   eqliscsiReplTxStatus            INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiReplSampleIndex  OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   MAX-ACCESS      not-accessible      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "An integer value to represent the sample."
 | 
						|
 | 
						|
::= { eqliscsiVolReplStatisticsEntry 1 }
 | 
						|
 | 
						|
eqliscsiReplStartTime  OBJECT-TYPE
 | 
						|
   SYNTAX          Counter32
 | 
						|
   UNITS           "seconds"
 | 
						|
   MAX-ACCESS      read-only      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "Time at which the replication started represented as number of seconds since epoch."
 | 
						|
 | 
						|
::= { eqliscsiVolReplStatisticsEntry 2 }
 | 
						|
 | 
						|
eqliscsiReplEndTime  OBJECT-TYPE
 | 
						|
   SYNTAX          Counter32
 | 
						|
   UNITS           "seconds"
 | 
						|
   MAX-ACCESS      read-only      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "Time at which the replication finished represented as number of seconds since epoch."
 | 
						|
 | 
						|
::= { eqliscsiVolReplStatisticsEntry 3 }
 | 
						|
 | 
						|
eqliscsiReplTxData  OBJECT-TYPE
 | 
						|
   SYNTAX           Counter64
 | 
						|
   UNITS           "MB"
 | 
						|
   MAX-ACCESS      read-only      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "The amount of data transfered from startTime to endTime in MB."
 | 
						|
 | 
						|
::= { eqliscsiVolReplStatisticsEntry 4 }
 | 
						|
 | 
						|
eqliscsiReplTxStatus  OBJECT-TYPE
 | 
						|
   SYNTAX          INTEGER 
 | 
						|
                    {
 | 
						|
                       in-progress(0),
 | 
						|
                       success(1),
 | 
						|
                       cancelled(2),
 | 
						|
                       failed(3),
 | 
						|
                       remoteReplicaSetIsFailoverVolume(4),
 | 
						|
                       incomplete(5)
 | 
						|
    }
 | 
						|
   MAX-ACCESS      read-only      
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "Status of data transfer for this replication. If replication is disabled,
 | 
						|
                    the status will be set to incomplete."
 | 
						|
 | 
						|
::= { eqliscsiVolReplStatisticsEntry 5 }
 | 
						|
--*************************************************************************
 | 
						|
 | 
						|
eqliscsiVolumeStatisticsTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeStatisticsEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage Volume Table.
 | 
						|
                     This table contains a list of volumes in a group and their statistics." 
 | 
						|
    ::=    { eqliscsiTarget 34 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeStatisticsEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeStatisticsEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing volume statistics."
 | 
						|
    AUGMENTS        { eqliscsiVolumeEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeStatisticsTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeStatisticsEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeStatsCmdPdus            Counter32,
 | 
						|
        eqliscsiVolumeStatsRspPdus            Counter32,
 | 
						|
        eqliscsiVolumeStatsTxData             Counter64,
 | 
						|
        eqliscsiVolumeStatsRxData             Counter64,
 | 
						|
        eqliscsiVolumeStatsNoOfSessions       Unsigned32,
 | 
						|
        eqliscsiVolumeStatsReadLatency        Counter64,
 | 
						|
        eqliscsiVolumeStatsWriteLatency       Counter64,
 | 
						|
        eqliscsiVolumeStatsReadOpCount        Counter64,
 | 
						|
        eqliscsiVolumeStatsWriteOpCount       Counter64,
 | 
						|
        eqliscsiVolumeStatsReadAvgLatency        Gauge32,
 | 
						|
        eqliscsiVolumeStatsWriteAvgLatency       Gauge32,
 | 
						|
        eqliscsiVolumeStatsIscsiReadWriteCmdsReceived  Counter32,
 | 
						|
        eqliscsiVolumeStatsIscsiReadWriteCmdsCompleted Counter32,
 | 
						|
        eqliscsiVolumeStatsHCIscsiReadWriteCmdsReceived  Counter64,
 | 
						|
        eqliscsiVolumeStatsHCIscsiTotalQD                Counter64,
 | 
						|
        eqliscsiVolumeStatsMisAlignedIO       Counter64
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeStatsCmdPdus OBJECT-TYPE
 | 
						|
    SYNTAX        Counter32
 | 
						|
    UNITS         "PDUs"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of Command PDUs transferred to this volume."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsRspPdus OBJECT-TYPE
 | 
						|
    SYNTAX        Counter32
 | 
						|
    UNITS         "PDUs"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of Response PDUs transferred to this volume."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 2 }
 | 
						|
    
 | 
						|
eqliscsiVolumeStatsTxData OBJECT-TYPE
 | 
						|
    SYNTAX         Counter64
 | 
						|
    UNITS         "octets"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of data octets that were transmitted by
 | 
						|
        the local iSCSI node."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 3 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsRxData OBJECT-TYPE
 | 
						|
    SYNTAX         Counter64
 | 
						|
    UNITS         "octets"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of data octets that were received by
 | 
						|
        the local iSCSI node."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 4 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsNoOfSessions OBJECT-TYPE
 | 
						|
    SYNTAX        Unsigned32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "No of sessions that were established and closed so far to this volume. 
 | 
						|
        "
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 5 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsReadLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The accumulative latency in milli seconds for read operations on this volume."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 6 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsWriteLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The accumulative latency in milli seconds for write operations on this volume."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 7 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsReadOpCount OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of read operations on this volume."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 8 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsWriteOpCount OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of write operations on this volume."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 9 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsReadAvgLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Gauge32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The average latency in milli seconds for read operations on this volume."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 10 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsWriteAvgLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Gauge32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The average latency in milli seconds for write operations on this volume."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 11 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsIscsiReadWriteCmdsReceived  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of iscsi read/write commands received for operations on this volume."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 12 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsIscsiReadWriteCmdsCompleted  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "A 32-bit counter that is incremented by the current number of outstanding iSCSI IO
 | 
						|
        operations each time an iSCSI IO is received by the target.  The iSCSI IO operations include
 | 
						|
        both reads and writes.  This counter when divided by the total number of iSCSI IO operations
 | 
						|
        provides the average queue depth."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 13 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsHCIscsiReadWriteCmdsReceived  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of iscsi read/write commands received for operations on this volume. 
 | 
						|
        This object is a 64-bit version of eqliscsiVolumeStatsIscsiReadWriteCmdsReceived."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 14 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsHCIscsiTotalQD  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "A 64-bit counter that is incremented by the current number of outstanding iSCSI IO
 | 
						|
        operations each time an iSCSI IO is received by the target.  The iSCSI IO operations include
 | 
						|
        both reads and writes.  This counter when divided by the total number of iSCSI IO operations
 | 
						|
        provides the average queue depth.
 | 
						|
        This object is a 64 bit version of eqliscsiVolumeStatsIscsiReadWriteCmdsCompleted."
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 15 }
 | 
						|
 | 
						|
eqliscsiVolumeStatsMisAlignedIO  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "A 64-bit counter that is incremented by the number of mis-aligned I/O operations performed on a volume
 | 
						|
        TODO - beef this up!!!!!" 
 | 
						|
::= { eqliscsiVolumeStatisticsEntry 16 }
 | 
						|
 | 
						|
--***********************************************************************************
 | 
						|
 | 
						|
 | 
						|
eqliscsiTargetTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiTargetEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent iSCSI Target Table.
 | 
						|
                     This table contains a list of iSCSI targets in a group and their attributes." 
 | 
						|
    ::=    { eqliscsiTarget 36 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiTargetEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiTargetEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing target info."
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiTargetIndex }
 | 
						|
    ::=   { eqliscsiTargetTable 1}     
 | 
						|
 | 
						|
EqliscsiTargetEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiTargetIndex               Unsigned32,   
 | 
						|
        eqliscsiTargetRowStatus           RowStatus,
 | 
						|
        eqliscsiTargetUUID                OCTET STRING,
 | 
						|
        eqliscsiTargetAlias               OCTET STRING, 
 | 
						|
        eqliscsiTargetIscsiName           OCTET STRING,
 | 
						|
        eqliscsiTargetReserved1           Unsigned32,
 | 
						|
        eqliscsiTargetReserved2           Unsigned32,
 | 
						|
        eqliscsiTargetReserved3           Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiTargetIndex OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing an iSCSI target."
 | 
						|
    ::=   { eqliscsiTargetEntry 1}
 | 
						|
 | 
						|
eqliscsiTargetRowStatus OBJECT-TYPE
 | 
						|
    SYNTAX          RowStatus
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."
 | 
						|
    ::= { eqliscsiTargetEntry 2 }  
 | 
						|
 | 
						|
eqliscsiTargetUUID OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field is for internal use only."
 | 
						|
    ::=  { eqliscsiTargetEntry 3 }
 | 
						|
 | 
						|
eqliscsiTargetAlias OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..64))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the iSCSI alias used for the target."
 | 
						|
    ::=  {  eqliscsiTargetEntry 4 }
 | 
						|
 | 
						|
eqliscsiTargetIscsiName OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..223))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies the iSCSI target name."
 | 
						|
    ::=  {  eqliscsiTargetEntry 5 }
 | 
						|
 | 
						|
eqliscsiTargetReserved1 OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is not currently used and is reserved."
 | 
						|
    ::=   { eqliscsiTargetEntry 6}
 | 
						|
 | 
						|
eqliscsiTargetReserved2 OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is not currently used and is reserved."
 | 
						|
    ::=   { eqliscsiTargetEntry 7}     
 | 
						|
 | 
						|
eqliscsiTargetReserved3 OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is not currently used and is reserved."
 | 
						|
    ::=   { eqliscsiTargetEntry 8}     
 | 
						|
 | 
						|
--**********************************************************************************
 | 
						|
 | 
						|
eqliscsiTargetChapSecretsTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiTargetChapSecretsEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Chap Secrets Table for iSCSI targets"
 | 
						|
    ::=    { eqliscsiTarget 37 }
 | 
						|
 | 
						|
eqliscsiTargetChapSecretsEntry OBJECT-TYPE
 | 
						|
    SYNTAX          EqliscsiTargetChapSecretsEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing a CHAP secret credential."
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiTargetIndex, eqliscsiTargetChapSecretsUsage, eqliscsiTargetChapSecretsIndex }
 | 
						|
    ::=    { eqliscsiTargetChapSecretsTable 1 }
 | 
						|
 | 
						|
EqliscsiTargetChapSecretsEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiTargetChapSecretsUsage          INTEGER,
 | 
						|
        eqliscsiTargetChapSecretsIndex          Unsigned32,
 | 
						|
        eqliscsiTargetChapSecretsRowStatus      RowStatus,
 | 
						|
        eqliscsiTargetChapSecretsUserName       OCTET STRING,
 | 
						|
        eqliscsiTargetChapSecretsPassword       OCTET STRING
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiTargetChapSecretsUsage OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
        inbound-iscsi-chap (1),
 | 
						|
        outbound-iscsi-chap (2),
 | 
						|
        inbound-repl-chap (3)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing a specific Chap credential."
 | 
						|
    ::=   { eqliscsiTargetChapSecretsEntry 1 }
 | 
						|
 | 
						|
eqliscsiTargetChapSecretsIndex OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing a specific Chap credential."
 | 
						|
    ::=   { eqliscsiTargetChapSecretsEntry 2 }
 | 
						|
 | 
						|
eqliscsiTargetChapSecretsRowStatus OBJECT-TYPE
 | 
						|
    SYNTAX          RowStatus
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."
 | 
						|
    ::= { eqliscsiTargetChapSecretsEntry 3 }  
 | 
						|
 | 
						|
eqliscsiTargetChapSecretsUserName OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING  (SIZE (0..255))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "EQL-SECONDARY-KEY
 | 
						|
         An octet string containing the user name for this credential."
 | 
						|
    ::= { eqliscsiTargetChapSecretsEntry 4 }
 | 
						|
    
 | 
						|
eqliscsiTargetChapSecretsPassword OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING  (SIZE (0..255))
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An octet string containing the password for this credential."
 | 
						|
    --DEFAULT       cookie "secure"
 | 
						|
    ::= { eqliscsiTargetChapSecretsEntry 5 }
 | 
						|
 | 
						|
--**********************************************************************************
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSnapshotPolicyStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage SnapSnot Policy Table.
 | 
						|
                     Note: eqliscsiSnapCollectionPolicyStatus entries (indexed by collection index and 
 | 
						|
                     policy index) are used along with eqliscsiVolumeSnapshotPolicyStatus entries (indexed
 | 
						|
                     by member index, volume index and policy index).   When they are used together,
 | 
						|
                     eqliscsiSnapCollectionPolicyStatus indexes have a member index of 0xffffffff"  
 | 
						|
    ::=  {  eqliscsiTarget 38 }    
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSnapshotPolicyStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry containing snapshot scheduling policy 
 | 
						|
                     information."
 | 
						|
    AUGMENTS        { eqliscsiVolumeSnapshotPolicyEntry }
 | 
						|
::=    { eqliscsiVolumeSnapshotPolicyStatusTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeSnapshotPolicyStatusEntry ::= 
 | 
						|
    SEQUENCE {     
 | 
						|
        eqliscsiVolumeSnapshotPolicyStatusNextCreate          Counter32,
 | 
						|
        eqliscsiVolumeSnapshotPolicyStatusOperStatus          INTEGER,
 | 
						|
        eqliscsiVolumeSnapshotPolicyStatusNoOfSnaps           INTEGER
 | 
						|
 | 
						|
    }
 | 
						|
eqliscsiVolumeSnapshotPolicyStatusNextCreate  OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32 
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this column represents number of seconds since epoch
 | 
						|
           at which the next snapshot by this policy is going to be created.
 | 
						|
          "
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyStatusEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyStatusOperStatus  OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                    enabled(0),
 | 
						|
                    disabled(1),
 | 
						|
                    expired(2)
 | 
						|
    }
 | 
						|
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this column represents the current operational status of this policy.
 | 
						|
           The policy status is set to expired after end date. 
 | 
						|
          "
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyStatusEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeSnapshotPolicyStatusNoOfSnaps  OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER 
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this column represents the current number of snapshots that exist in the system
 | 
						|
           created by this schedule.
 | 
						|
          "
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiVolumeSnapshotPolicyStatusEntry 3 }
 | 
						|
--*******************************************************************************
 | 
						|
eqliscsiSnapCollectionPolicyStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiSnapCollectionPolicyStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage SnapSnot Collection Policy Table.
 | 
						|
                     Note: eqliscsiSnapCollectionPolicyStatus entries (indexed by collection index and 
 | 
						|
                     policy index) are used along with eqliscsiVolumeSnapshotPolicyStatus entries (indexed
 | 
						|
                     by member index, volume index and policy index).   When they are used together,
 | 
						|
                     eqliscsiSnapCollectionPolicyStatus indexes have a member index of 0xffffffff"  
 | 
						|
    ::=  {  eqliscsiTarget 39 }    
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiSnapCollectionPolicyStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry containing snapshot scheduling policy 
 | 
						|
                     information."
 | 
						|
    AUGMENTS        { eqliscsiSnapCollectionPolicyEntry }
 | 
						|
::=    { eqliscsiSnapCollectionPolicyStatusTable 1 }
 | 
						|
 | 
						|
EqliscsiSnapCollectionPolicyStatusEntry ::= 
 | 
						|
    SEQUENCE {     
 | 
						|
        eqliscsiSnapCollectionPolicyStatusNextCreate          Counter32,
 | 
						|
        eqliscsiSnapCollectionPolicyStatusOperStatus          INTEGER,
 | 
						|
        eqliscsiSnapCollectionPolicyStatusNoOfCollections     INTEGER
 | 
						|
    }
 | 
						|
eqliscsiSnapCollectionPolicyStatusNextCreate  OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32 
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this column represents number of seconds since epoch
 | 
						|
           at which the next snapshot by this policy is going to be created.
 | 
						|
          "
 | 
						|
 
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyStatusEntry 1 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyStatusOperStatus  OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                    enabled(0),
 | 
						|
                    disabled(1),
 | 
						|
                    expired(2)
 | 
						|
    }
 | 
						|
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this column represents the current operational status of this policy.
 | 
						|
           The policy status is set to expired after end date. 
 | 
						|
          "
 | 
						|
    ::=  {  eqliscsiSnapCollectionPolicyStatusEntry 2 }
 | 
						|
 | 
						|
eqliscsiSnapCollectionPolicyStatusNoOfCollections  OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER 
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          "
 | 
						|
           The value of this column represents the current number of snapshots that exist in the system
 | 
						|
           created by this schedule.
 | 
						|
          "
 | 
						|
 
 | 
						|
    ::=  { eqliscsiSnapCollectionPolicyStatusEntry  3 }
 | 
						|
 | 
						|
 | 
						|
--*******************************************************************************
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeOpsTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeOpsEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Storage Volume Operations Table."
 | 
						|
    ::=    { eqliscsiTarget 40 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeOpsEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeOpsEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing info for volume operations."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex, eqliscsiVolumeOpsIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeOpsTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeOpsEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeOpsIndex                           Unsigned32,   
 | 
						|
        eqliscsiVolumeOpsRowStatus                       RowStatus,
 | 
						|
        eqliscsiVolumeOpsOperation                       INTEGER,
 | 
						|
        eqliscsiVolumeOpsExec                            INTEGER,
 | 
						|
        eqliscsiVolumeOpsStartTime                       Counter32,
 | 
						|
        eqliscsiVolumeOpsStoragePoolSourceIndex          Unsigned32,
 | 
						|
        eqliscsiVolumeOpsStoragePoolDestinationIndex     Unsigned32,
 | 
						|
        eqliscsiVolumeOpsVolBalCommandIndex              Unsigned32,
 | 
						|
        eqliscsiVolumeOpsVolBalCommandiscsiLocalMemberId Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeOpsIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      not-accessible     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing a volume."  
 | 
						|
    ::=   { eqliscsiVolumeOpsEntry 1}     
 | 
						|
 | 
						|
eqliscsiVolumeOpsRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiVolumeOpsEntry 2 }  
 | 
						|
 | 
						|
eqliscsiVolumeOpsOperation OBJECT-TYPE
 | 
						|
    SYNTAX INTEGER {
 | 
						|
        none(0),
 | 
						|
        movePool(1)
 | 
						|
    }
 | 
						|
    MAX-ACCESS     read-write
 | 
						|
    STATUS         current
 | 
						|
    DESCRIPTION    "The current operation for this drive group
 | 
						|
                        0 - no operation
 | 
						|
                        1 - move Pool"
 | 
						|
    ::=  {  eqliscsiVolumeOpsEntry 3 }
 | 
						|
 | 
						|
eqliscsiVolumeOpsExec OBJECT-TYPE
 | 
						|
    SYNTAX INTEGER {
 | 
						|
        none(0),
 | 
						|
        cancel(1),
 | 
						|
        failed(2)
 | 
						|
    }
 | 
						|
    MAX-ACCESS     read-write
 | 
						|
    STATUS         current
 | 
						|
    DESCRIPTION    "The action to perform on this operation
 | 
						|
                        0 - no operation
 | 
						|
                        1 - cancel
 | 
						|
                        2 - failed"
 | 
						|
    ::=  {  eqliscsiVolumeOpsEntry 4 }
 | 
						|
 | 
						|
eqliscsiVolumeOpsStartTime OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32    
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field contains the time of the start of the operation."
 | 
						|
    ::=  {  eqliscsiVolumeOpsEntry 5 }
 | 
						|
 
 | 
						|
eqliscsiVolumeOpsStoragePoolSourceIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field unique identifies the source Storage Pool.
 | 
						|
                     Also the 1st part of Index for row in eqliscsiVolBalCommandTable."
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=  {  eqliscsiVolumeOpsEntry 6 }  
 | 
						|
    
 | 
						|
eqliscsiVolumeOpsStoragePoolDestinationIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field unique identifies the destination Storage Pool."
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=  {  eqliscsiVolumeOpsEntry 7 }  
 | 
						|
 | 
						|
eqliscsiVolumeOpsVolBalCommandIndex OBJECT-TYPE
 | 
						|
    SYNTAX      Unsigned32
 | 
						|
    MAX-ACCESS  read-create
 | 
						|
    STATUS      current
 | 
						|
    DESCRIPTION "2nd Part of Index for row in eqliscsiVolBalCommandTable"
 | 
						|
    ::=  {  eqliscsiVolumeOpsEntry 8 }
 | 
						|
 | 
						|
eqliscsiVolumeOpsVolBalCommandiscsiLocalMemberId OBJECT-TYPE
 | 
						|
    SYNTAX      Unsigned32
 | 
						|
    MAX-ACCESS  read-create
 | 
						|
    STATUS      current
 | 
						|
    DESCRIPTION "3rd Part of Index for row in eqliscsiVolBalCommandTable"
 | 
						|
    ::=  {  eqliscsiVolumeOpsEntry 9 }
 | 
						|
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
-- 
 | 
						|
-- ReplicaSetExtension table
 | 
						|
-- 
 | 
						|
 | 
						|
eqliscsiReplicaSetExtensionTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiReplicaSetExtensionEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent"
 | 
						|
::= { eqliscsiTarget 41 }
 | 
						|
 | 
						|
eqliscsiReplicaSetExtensionEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiReplicaSetExtensionEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      " This table maintains the information required by the volume if replicaset gets promoted to a volume."
 | 
						|
    AUGMENTS        { eqliscsiReplicaSetEntry }
 | 
						|
::= { eqliscsiReplicaSetExtensionTable 1 }
 | 
						|
 | 
						|
EqliscsiReplicaSetExtensionEntry ::= SEQUENCE {
 | 
						|
   eqliscsiReplicaSetPrimaryPsvId   OCTET STRING
 | 
						|
}
 | 
						|
 | 
						|
 | 
						|
eqliscsiReplicaSetPrimaryPsvId  OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "If non-zero, the value represents the PsvId of primary site volume. 
 | 
						|
                     The value is used by iscsi during page83 and page80 requests."
 | 
						|
    DEFVAL          { "" }
 | 
						|
::= { eqliscsiReplicaSetExtensionEntry 1 }
 | 
						|
 | 
						|
 | 
						|
-- 
 | 
						|
-- volume storage preference table
 | 
						|
-- 
 | 
						|
 | 
						|
eqliscsiVolumeStoragePreferenceTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeStoragePreferenceEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent"
 | 
						|
::= { eqliscsiTarget 42 }
 | 
						|
 | 
						|
eqliscsiVolumeStoragePreferenceEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeStoragePreferenceEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      " This table maintains the information related to storage preference of volumes."
 | 
						|
    AUGMENTS        { eqliscsiVolumeEntry }
 | 
						|
::= { eqliscsiVolumeStoragePreferenceTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeStoragePreferenceEntry ::= SEQUENCE {
 | 
						|
        eqliscsiVolumeStoragePreferenceRowStatus           RowStatus,
 | 
						|
        eqliscsiVolumeStoragePreferenceRAIDType   INTEGER,
 | 
						|
        eqliscsiVolumeStoragePreferenceDriveType  INTEGER,
 | 
						|
        eqliscsiVolumeStoragePreferenceDiskSpeed  INTEGER,
 | 
						|
        eqliscsiVolumeStoragePreferenceRAIDTypeStatus   INTEGER
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolumeStoragePreferenceRowStatus OBJECT-TYPE
 | 
						|
    SYNTAX      RowStatus
 | 
						|
    MAX-ACCESS  read-create
 | 
						|
    STATUS      current
 | 
						|
    DESCRIPTION  "Rowstatus variable used to manage rows in this table."
 | 
						|
  ::={ eqliscsiVolumeStoragePreferenceEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeStoragePreferenceRAIDType OBJECT-TYPE
 | 
						|
    SYNTAX INTEGER {
 | 
						|
        none(0),
 | 
						|
        raid5(5),
 | 
						|
        raid6(6),
 | 
						|
        raid10(10),
 | 
						|
        raid50(50),
 | 
						|
        raid60(60),
 | 
						|
        raid6-accelerated(61)
 | 
						|
    }
 | 
						|
  MAX-ACCESS  read-create
 | 
						|
  STATUS   current
 | 
						|
  DESCRIPTION  "EQL-SECONDARY-KEY This field specifies the user's request to store this volume on the given RAID type."
 | 
						|
  ::={ eqliscsiVolumeStoragePreferenceEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeStoragePreferenceDriveType OBJECT-TYPE
 | 
						|
  SYNTAX INTEGER {
 | 
						|
              none(0),
 | 
						|
              sas(1),
 | 
						|
              sata(2)
 | 
						|
     }
 | 
						|
  MAX-ACCESS  read-create
 | 
						|
  STATUS   current
 | 
						|
  DESCRIPTION  "EQL-SECONDARY-KEY This field specifies the user's request to store this volume on the given drive type."
 | 
						|
  ::={ eqliscsiVolumeStoragePreferenceEntry 3 }
 | 
						|
 | 
						|
eqliscsiVolumeStoragePreferenceDiskSpeed OBJECT-TYPE
 | 
						|
  SYNTAX INTEGER {
 | 
						|
              none(0),
 | 
						|
              s5400(5400),
 | 
						|
              s7200(7200),
 | 
						|
              s10000(10000),
 | 
						|
              s15000(15000)
 | 
						|
     }
 | 
						|
  MAX-ACCESS  read-create
 | 
						|
  STATUS   current
 | 
						|
  DESCRIPTION  "EQL-SECONDARY-KEY This field specifies the user's request to store this volume on the disks with given speed."
 | 
						|
  ::={ eqliscsiVolumeStoragePreferenceEntry 4 }
 | 
						|
 | 
						|
eqliscsiVolumeStoragePreferenceRAIDTypeStatus  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                    none(0),
 | 
						|
                    in-progress(1),
 | 
						|
                    honored(2),
 | 
						|
                    not-available(3),
 | 
						|
                    over-subscribed(4),
 | 
						|
                    temporarily-unknown(5)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY The value of this object represents current status of raid preference set on this volume.
 | 
						|
                    "
 | 
						|
    DEFVAL           { 0 }
 | 
						|
    ::=   {eqliscsiVolumeStoragePreferenceEntry 5 }
 | 
						|
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqlAdminAccountVolumeTable OBJECT-TYPE
 | 
						|
    SYNTAX          SEQUENCE OF EqlAdminAccountVolumeEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic table indicating the access an administrator
 | 
						|
                     has to a volume."
 | 
						|
    ::= { eqliscsiTarget 43 }
 | 
						|
 | 
						|
eqlAdminAccountVolumeEntry OBJECT-TYPE
 | 
						|
    SYNTAX          EqlAdminAccountVolumeEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing the access privilege."
 | 
						|
    INDEX           {  eqlGroupId, eqlStorageGroupAdminAccountIndex, eqliscsiLocalMemberId, eqliscsiVolumeIndex }
 | 
						|
    ::=   { eqlAdminAccountVolumeTable 1 }
 | 
						|
 | 
						|
EqlAdminAccountVolumeEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqlAdminAccountVolumeAccess         INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqlAdminAccountVolumeAccess OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                         read-only (1),
 | 
						|
                         read-write (2)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "The administrative permission to a volume."
 | 
						|
    ::=   { eqlAdminAccountVolumeEntry 1 }
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqlAdminAccountReplicantSiteTable OBJECT-TYPE
 | 
						|
    SYNTAX          SEQUENCE OF EqlAdminAccountReplicantSiteEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic table indicating the access an administrator
 | 
						|
                     has to a partner."
 | 
						|
    ::= { eqliscsiTarget 44 }
 | 
						|
 | 
						|
eqlAdminAccountReplicantSiteEntry OBJECT-TYPE
 | 
						|
    SYNTAX          EqlAdminAccountReplicantSiteEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing the access privilege."
 | 
						|
    INDEX           {  eqlGroupId, eqlStorageGroupAdminAccountIndex, eqliscsiReplicantSiteIndex }
 | 
						|
    ::=   { eqlAdminAccountReplicantSiteTable 1 }
 | 
						|
 | 
						|
EqlAdminAccountReplicantSiteEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqlAdminAccountReplicantSiteAccess         INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqlAdminAccountReplicantSiteAccess OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                         read-only (1),
 | 
						|
                         read-write (2)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "The administrative permission to a partner."
 | 
						|
    ::=   { eqlAdminAccountReplicantSiteEntry 1 }
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqlAdminAccountVolCollectionTable OBJECT-TYPE
 | 
						|
    SYNTAX          SEQUENCE OF EqlAdminAccountVolCollectionEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic table indicating the access an administrator
 | 
						|
                     has to a volume collection."
 | 
						|
    ::= { eqliscsiTarget 45 }
 | 
						|
 | 
						|
eqlAdminAccountVolCollectionEntry OBJECT-TYPE
 | 
						|
    SYNTAX          EqlAdminAccountVolCollectionEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing the access privilege."
 | 
						|
    INDEX           {  eqlGroupId, eqlStorageGroupAdminAccountIndex, eqliscsiVolCollectionIndex }
 | 
						|
    ::=   { eqlAdminAccountVolCollectionTable 1 }
 | 
						|
 | 
						|
EqlAdminAccountVolCollectionEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqlAdminAccountVolCollectionAccess         INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqlAdminAccountVolCollectionAccess OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER {
 | 
						|
                         read-only (1),
 | 
						|
                         read-write (2)
 | 
						|
                    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "The administrative permission to a volume collection."
 | 
						|
    ::=   { eqlAdminAccountVolCollectionEntry 1 }
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiVolumeOpsStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeOpsStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage Volume Operations Status Table."
 | 
						|
    ::=    { eqliscsiTarget 46 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeOpsStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeOpsStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing status for volume operations."
 | 
						|
    AUGMENTS        { eqliscsiVolumeOpsEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeOpsStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeOpsStatusEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeOpsStatusCompletePct            Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeOpsStatusCompletePct  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The percentage complete an ongoing move or bind operation is"
 | 
						|
    ::=   {eqliscsiVolumeOpsStatusEntry 1 }
 | 
						|
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiVolumeDynamicConfigTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeDynamicConfigEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Table for storing in database volume attributes that can frequently change.
 | 
						|
                    "
 | 
						|
    ::=    { eqliscsiTarget 47 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeDynamicConfigEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeDynamicConfigEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing status for volume dynamic config. The values in this table are not user
 | 
						|
                     configurable."
 | 
						|
    AUGMENTS        { eqliscsiVolumeEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeDynamicConfigTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeDynamicConfigEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeDynamicRowStatus              RowStatus,
 | 
						|
        eqliscsiVolumeDynamicThinReserve            Unsigned32,
 | 
						|
        eqliscsiVolumeDynamicInUseHighWaterMark     Unsigned32,
 | 
						|
        eqliscsiVolumeDynamicInUseHighWaterMarkTimestamp     Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeDynamicRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used to create new entries and indicate the status of this entry."  
 | 
						|
    ::=   { eqliscsiVolumeDynamicConfigEntry 1}
 | 
						|
 | 
						|
eqliscsiVolumeDynamicThinReserve  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the amount of pool free space that is currently reserved 
 | 
						|
                     for this Thin Provisioned Volume. A row will only exist in this table if 
 | 
						|
                     thin-provisioning is enabled on the volume. A row will not exist for classic volumes or
 | 
						|
                     if thin-provisioing is disabled."
 | 
						|
    ::=   { eqliscsiVolumeDynamicConfigEntry 2}
 | 
						|
 | 
						|
eqliscsiVolumeDynamicInUseHighWaterMark OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the high water mark of the volume's in-use."
 | 
						|
    DEFVAL { 0 }
 | 
						|
    ::=   { eqliscsiVolumeDynamicConfigEntry 3}
 | 
						|
 | 
						|
eqliscsiVolumeDynamicInUseHighWaterMarkTimestamp OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "seconds"
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the creation time for high water mark
 | 
						|
                     of the volume's in-use. Time is represented as the time in
 | 
						|
                     seconds since 00:00:00 UTC, 1970-01-01."
 | 
						|
    DEFVAL { 0 }
 | 
						|
    ::=   { eqliscsiVolumeDynamicConfigEntry 4}
 | 
						|
--
 | 
						|
-- Site Status table
 | 
						|
-- 
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteStatusTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeReplSiteStatusEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Dynamic"
 | 
						|
::= { eqliscsiTarget 48 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteStatusEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeReplSiteStatusEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION   "partner related status information"
 | 
						|
    AUGMENTS        { eqliscsiVolumeReplSiteEntry }
 | 
						|
::= { eqliscsiVolumeReplSiteStatusTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeReplSiteStatusEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolumeReplSiteFailbackSpace       Unsigned32
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteFailbackSpace    OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32 
 | 
						|
   UNITS         "MB"
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents the space consumed by of all failback replicasets that belong to this partner."
 | 
						|
::= { eqliscsiVolumeReplSiteStatusEntry 1 }
 | 
						|
 | 
						|
 | 
						|
--
 | 
						|
-- Volume Chunk Table
 | 
						|
-- 
 | 
						|
 | 
						|
eqliscsiVolumeChunkTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeChunkEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Dynamic. This table exposes the volume as number of chunks."
 | 
						|
::= { eqliscsiTarget 49 }
 | 
						|
 | 
						|
eqliscsiVolumeChunkEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeChunkEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION   "Information related to each chunk."
 | 
						|
    INDEX        { eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeChunkIndex }
 | 
						|
::= { eqliscsiVolumeChunkTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeChunkEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolumeChunkIndex         Unsigned32,
 | 
						|
   eqliscsiVolumeChunkVersion       Unsigned32,
 | 
						|
   eqliscsiVolumeChunkSegmentSize   Unsigned32,
 | 
						|
   eqliscsiVolumeChunkSegments      Unsigned32,
 | 
						|
   eqliscsiVolumeChunkModified      OCTET STRING
 | 
						|
}
 | 
						|
eqliscsiVolumeChunkIndex    OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32 
 | 
						|
   MAX-ACCESS    not-accessible
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents index of the chunk. "
 | 
						|
::= { eqliscsiVolumeChunkEntry 1 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeChunkVersion    OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32 
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents version of the chunk. Different versions of chunks can be of different sizes. Currently chunks with version 1 are supported."
 | 
						|
   DEFVAL {1}
 | 
						|
::= { eqliscsiVolumeChunkEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeChunkSegmentSize    OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32 
 | 
						|
   UNITS         "KB"
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents the size of a segment. In chunk version 1, segment size is 256k bytes of data."
 | 
						|
::= { eqliscsiVolumeChunkEntry 3 }
 | 
						|
 | 
						|
eqliscsiVolumeChunkSegments    OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32 
 | 
						|
   UNITS         "segments"
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents the size of the chunk expressed as number of segments. "
 | 
						|
::= { eqliscsiVolumeChunkEntry 4 }
 | 
						|
 | 
						|
eqliscsiVolumeChunkModified    OBJECT-TYPE
 | 
						|
   SYNTAX        OCTET STRING (SIZE(1024))
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents a bit mask of modified segments in the given chunk."
 | 
						|
::= { eqliscsiVolumeChunkEntry 5 }
 | 
						|
 | 
						|
--*******************************************************************************
 | 
						|
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiReplicantSiteOpsEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Replicant Site Operations Table."
 | 
						|
    ::=    { eqliscsiTarget 50 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiReplicantSiteOpsEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing info for replicant site operations."
 | 
						|
    INDEX           { eqlGroupId , eqliscsiReplicantSiteIndex, eqliscsiReplicantSiteOpsIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiReplicantSiteOpsTable 1}     
 | 
						|
 | 
						|
EqliscsiReplicantSiteOpsEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiReplicantSiteOpsIndex                           Unsigned32,   
 | 
						|
        eqliscsiReplicantSiteOpsRowStatus                       RowStatus,
 | 
						|
        eqliscsiReplicantSiteOpsOperation                       INTEGER,
 | 
						|
        eqliscsiReplicantSiteOpsExec                            INTEGER,
 | 
						|
        eqliscsiReplicantSiteOpsStartTime                       Counter32,
 | 
						|
        eqliscsiReplicantSiteOpsStoragePoolSourceIndex          Unsigned32,
 | 
						|
        eqliscsiReplicantSiteOpsStoragePoolDestinationIndex     Unsigned32,
 | 
						|
        eqliscsiReplicantSiteOpsVolBalCommandIndex              Unsigned32,
 | 
						|
        eqliscsiReplicantSiteOpsVolBalCommandiscsiLocalMemberId Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      not-accessible     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing a replicant site operation."  
 | 
						|
    ::=   { eqliscsiReplicantSiteOpsEntry 1}     
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiReplicantSiteOpsEntry 2 }  
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsOperation OBJECT-TYPE
 | 
						|
    SYNTAX INTEGER {
 | 
						|
        none(0),
 | 
						|
        movePool(1)
 | 
						|
    }
 | 
						|
    MAX-ACCESS     read-write
 | 
						|
    STATUS         current
 | 
						|
    DESCRIPTION    "The current operation for this drive group
 | 
						|
                        0 - no operation
 | 
						|
                        1 - move Pool"
 | 
						|
    ::=  {  eqliscsiReplicantSiteOpsEntry 3 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsExec OBJECT-TYPE
 | 
						|
    SYNTAX INTEGER {
 | 
						|
        none(0),
 | 
						|
        cancel(1),
 | 
						|
        failed(2)
 | 
						|
    }
 | 
						|
    MAX-ACCESS     read-write
 | 
						|
    STATUS         current
 | 
						|
    DESCRIPTION    "The action to perform on this operation
 | 
						|
                        0 - no operation
 | 
						|
                        1 - cancel
 | 
						|
                        2 - failed"
 | 
						|
    ::=  {  eqliscsiReplicantSiteOpsEntry 4 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsStartTime OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32    
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field contains the time of the start of the operation."
 | 
						|
    ::=  {  eqliscsiReplicantSiteOpsEntry 5 }
 | 
						|
 
 | 
						|
eqliscsiReplicantSiteOpsStoragePoolSourceIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field unique identifies the source Storage Pool.
 | 
						|
                     Also the 1st part of Index for row in eqliscsiVolBalCommandTable."
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=  {  eqliscsiReplicantSiteOpsEntry 6 }  
 | 
						|
    
 | 
						|
eqliscsiReplicantSiteOpsStoragePoolDestinationIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field unique identifies the destination Storage Pool."
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=  {  eqliscsiReplicantSiteOpsEntry 7 }  
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsVolBalCommandIndex OBJECT-TYPE
 | 
						|
    SYNTAX      Unsigned32
 | 
						|
    MAX-ACCESS  read-create
 | 
						|
    STATUS      current
 | 
						|
    DESCRIPTION "2nd Part of Index for row in eqliscsiVolBalCommandTable"
 | 
						|
    ::=  {  eqliscsiReplicantSiteOpsEntry 8 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsVolBalCommandiscsiLocalMemberId OBJECT-TYPE
 | 
						|
    SYNTAX      Unsigned32
 | 
						|
    MAX-ACCESS  read-create
 | 
						|
    STATUS      current
 | 
						|
    DESCRIPTION "3rd Part of Index for row in eqliscsiVolBalCommandTable"
 | 
						|
    ::=  {  eqliscsiReplicantSiteOpsEntry 9 }
 | 
						|
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiReplicantSiteOpsStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Replicant Site Operations Status Table."
 | 
						|
    ::=    { eqliscsiTarget 51 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiReplicantSiteOpsStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing status for replicant site operations."
 | 
						|
    AUGMENTS        { eqliscsiReplicantSiteOpsEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiReplicantSiteOpsStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiReplicantSiteOpsStatusEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiReplicantSiteOpsStatusCompletePct            Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiReplicantSiteOpsStatusCompletePct  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The percentage complete an ongoing move or bind operation is"
 | 
						|
    ::=   {eqliscsiReplicantSiteOpsStatusEntry 1 }
 | 
						|
 | 
						|
 | 
						|
-- 
 | 
						|
-- Replicant Site Status Table
 | 
						|
--
 | 
						|
 | 
						|
eqliscsiReplicantSiteStatusTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiReplicantSiteStatusEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Dynamic
 | 
						|
      The replicant site status table contains the status of
 | 
						|
      all the remote replication sites which have been given 
 | 
						|
      access to the local storage pool for the purposes of 
 | 
						|
      creating replica sets."
 | 
						|
::= { eqliscsiTarget 52 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteStatusEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiReplicantSiteStatusEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      ""
 | 
						|
    AUGMENTS      { eqliscsiReplicantSiteEntry }
 | 
						|
::= { eqliscsiReplicantSiteStatusTable 1 }
 | 
						|
 | 
						|
EqliscsiReplicantSiteStatusEntry ::= SEQUENCE {
 | 
						|
   eqliscsiReplicantSiteStatusAvailable     INTEGER,
 | 
						|
   eqliscsiReplicantSiteStatusMajorVersion  Unsigned32,
 | 
						|
   eqliscsiReplicantSiteStatusMinorVersion  Unsigned32,
 | 
						|
   eqliscsiReplicantSiteStatusMaintVersion  Unsigned32
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiReplicantSiteStatusAvailable     OBJECT-TYPE
 | 
						|
   SYNTAX      INTEGER {
 | 
						|
                 not-available(1),
 | 
						|
                 available(2)
 | 
						|
   }
 | 
						|
   MAX-ACCESS  read-only
 | 
						|
   STATUS      current
 | 
						|
   DESCRIPTION " The current availability of the remote site"
 | 
						|
    ::=  { eqliscsiReplicantSiteStatusEntry  1 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteStatusMajorVersion  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This variable specifies the Major part of 
 | 
						|
                     the lowest member software version of the 
 | 
						|
                     remote replication site group."
 | 
						|
    DEFVAL          { 3 }
 | 
						|
    ::=  { eqliscsiReplicantSiteStatusEntry  2 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteStatusMinorVersion  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This variable specifies the Minor part of 
 | 
						|
                     the lowest member software version of the 
 | 
						|
                     remote replication site group."
 | 
						|
    DEFVAL          { 2 }
 | 
						|
    ::=  { eqliscsiReplicantSiteStatusEntry  3 }
 | 
						|
 | 
						|
eqliscsiReplicantSiteStatusMaintVersion  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This variable specifies the Maintenance 
 | 
						|
                     part of the lowest member software version
 | 
						|
                     of the remote replication site group."
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=  { eqliscsiReplicantSiteStatusEntry  4 }
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
eqliscsiVolumeTaskStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeTaskStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage Volume Operations Status Table."
 | 
						|
    ::=    { eqliscsiTarget 53 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeTaskStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeTaskStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing status for volume operations."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex, eqlGroupTaskIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeTaskStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeTaskStatusEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeTaskStatusErrorCode  Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeTaskStatusErrorCode  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "Error if any occurred while executing the task on this volume."
 | 
						|
    DEFVAL          {0}
 | 
						|
    ::=   {eqliscsiVolumeTaskStatusEntry 1 }
 | 
						|
 | 
						|
 | 
						|
 | 
						|
--*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeTemplateThinClonesTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeTemplateThinClonesEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage Template Thin Clone Table"  
 | 
						|
    ::=  {  eqliscsiTarget 54 }    
 | 
						|
 | 
						|
eqliscsiVolumeTemplateThinClonesEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeTemplateThinClonesEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing a templates thin clone info. The first 2 indices are the volume index of the
 | 
						|
                     template volume and the second 2 indicies are the volume index of the thin clone."
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiThinCloneLocalMemberId, eqliscsiThinCloneVolumeIndex }
 | 
						|
    ::=    { eqliscsiVolumeTemplateThinClonesTable 1 }
 | 
						|
 | 
						|
    
 | 
						|
EqliscsiVolumeTemplateThinClonesEntry ::= 
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiThinCloneLocalMemberId  Unsigned32,
 | 
						|
        eqliscsiThinCloneVolumeIndex    Unsigned32,
 | 
						|
        eqliscsiVolumeTemplateThinClonesMember TruthValue 
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiThinCloneLocalMemberId  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the first part of a unique index for identifing a the thin clone."  
 | 
						|
    ::=  {eqliscsiVolumeTemplateThinClonesEntry 1 }
 | 
						|
  
 | 
						|
eqliscsiThinCloneVolumeIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the second part of a unique index for identifing a thin clone."  
 | 
						|
    ::=  {eqliscsiVolumeTemplateThinClonesEntry 2 }
 | 
						|
  
 | 
						|
eqliscsiVolumeTemplateThinClonesMember   OBJECT-TYPE
 | 
						|
   SYNTAX            TruthValue
 | 
						|
   MAX-ACCESS        read-only
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "Always true."
 | 
						|
   DEFVAL            {true}
 | 
						|
   ::=   {eqliscsiVolumeTemplateThinClonesEntry 3 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeAdminAccountTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeAdminAccountEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Admin Account Volume Table.
 | 
						|
                     This table contains a list of privilege matchings of administrative
 | 
						|
                     accounts and the volumes those administrators have access to."
 | 
						|
    ::=    { eqliscsiTarget 55 }     
 | 
						|
 | 
						|
eqliscsiVolumeAdminAccountEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeAdminAccountEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing mapping of administrative accounts and their
 | 
						|
                     volume access."
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqlStorageGroupAdminAccountIndex }
 | 
						|
    ::=   { eqliscsiVolumeAdminAccountTable 1}
 | 
						|
 | 
						|
EqliscsiVolumeAdminAccountEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeAdminAccountRowStatus RowStatus
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeAdminAccountRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiVolumeAdminAccountEntry 1 }  
 | 
						|
 | 
						|
--*************************************************************************
 | 
						|
 | 
						|
eqliscsiTemplateVolumeStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiTemplateVolumeStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage template Volume status Table.
 | 
						|
                     This table contains a list of template volumes in a group and their stats." 
 | 
						|
    ::=    { eqliscsiTarget 56 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiTemplateVolumeStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiTemplateVolumeStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing template volume stats."
 | 
						|
    AUGMENTS        { eqliscsiVolumeEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiTemplateVolumeStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiTemplateVolumeStatusEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiTemplateVolumeStatusNumThinClones                  Unsigned32,
 | 
						|
        eqliscsiTemplateVolumeStatusNumThinCloneReplicators        Unsigned32,
 | 
						|
        eqliscsiTemplateVolumeStatusNumThinCloneReplicaSets        Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiTemplateVolumeStatusNumThinClones   OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "This field represents the number of thin clones associated with a template volume."
 | 
						|
    ::=   {eqliscsiTemplateVolumeStatusEntry 1 }
 | 
						|
 | 
						|
eqliscsiTemplateVolumeStatusNumThinCloneReplicators  OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "This field represents the number of thin clone replicators associated with a template volume."
 | 
						|
    ::=   {eqliscsiTemplateVolumeStatusEntry 2 }
 | 
						|
 | 
						|
eqliscsiTemplateVolumeStatusNumThinCloneReplicaSets  OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "This field represents the number of thin clone replica sets associated with a template volume."
 | 
						|
    ::=   {eqliscsiTemplateVolumeStatusEntry 3 }
 | 
						|
 | 
						|
--
 | 
						|
-- Accumulated snap/replication Statistics Table
 | 
						|
--
 | 
						|
eqliscsiSnapAccumulatedStatisticsTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiSnapAccumulatedStatisticsEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Dynamic
 | 
						|
      This table contains a list inbound-replica sets and their statistics."
 | 
						|
::= { eqliscsiTarget 57 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatisticsEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiSnapAccumulatedStatisticsEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing inbound-replicaset statistics."
 | 
						|
    AUGMENTS        { eqliscsiVolumeEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiSnapAccumulatedStatisticsTable 1}     
 | 
						|
 | 
						|
 | 
						|
EqliscsiSnapAccumulatedStatisticsEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiSnapAccumulatedStatsCmdPdus            Counter32,
 | 
						|
        eqliscsiSnapAccumulatedStatsRspPdus            Counter32,
 | 
						|
        eqliscsiSnapAccumulatedStatsTxData             Counter64,
 | 
						|
        eqliscsiSnapAccumulatedStatsRxData             Counter64,
 | 
						|
        eqliscsiSnapAccumulatedStatsNoOfSessions       Unsigned32,
 | 
						|
        eqliscsiSnapAccumulatedStatsReadLatency        Counter64,
 | 
						|
        eqliscsiSnapAccumulatedStatsWriteLatency       Counter64,
 | 
						|
        eqliscsiSnapAccumulatedStatsReadOpCount        Counter64,
 | 
						|
        eqliscsiSnapAccumulatedStatsWriteOpCount       Counter64,
 | 
						|
        eqliscsiSnapAccumulatedStatsReadAvgLatency        Gauge32,
 | 
						|
        eqliscsiSnapAccumulatedStatsWriteAvgLatency       Gauge32,
 | 
						|
        eqliscsiSnapAccumulatedStatsIscsiReadWriteCmdsReceived  Counter64,
 | 
						|
        eqliscsiSnapAccumulatedStatsIscsiTotalQD                Counter64
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsCmdPdus OBJECT-TYPE
 | 
						|
    SYNTAX        Counter32
 | 
						|
    UNITS         "PDUs"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of Command PDUs transferred to this snapshot."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 1 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsRspPdus OBJECT-TYPE
 | 
						|
    SYNTAX        Counter32
 | 
						|
    UNITS         "PDUs"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of Response PDUs transferred to this snapshot."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 2 }
 | 
						|
    
 | 
						|
eqliscsiSnapAccumulatedStatsTxData OBJECT-TYPE
 | 
						|
    SYNTAX         Counter64
 | 
						|
    UNITS         "octets"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of data octets that were transmitted by
 | 
						|
        the local iSCSI node."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 3 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsRxData OBJECT-TYPE
 | 
						|
    SYNTAX         Counter64
 | 
						|
    UNITS         "octets"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of data octets that were received by
 | 
						|
        the local iSCSI node."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 4 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsNoOfSessions OBJECT-TYPE
 | 
						|
    SYNTAX        Unsigned32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "No of sessions that were established and closed so far to this snapshot. 
 | 
						|
        "
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 5 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsReadLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The accumulative latency in milli seconds for read operations on this snapshot."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 6 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsWriteLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The accumulative latency in milli seconds for write operations on this snapshot."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 7 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsReadOpCount OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of read operations on this snapshot."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 8 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsWriteOpCount OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of write operations on this snapshot."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 9 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsReadAvgLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Gauge32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The average latency in milli seconds for read operations on this snapshot."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 10 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsWriteAvgLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Gauge32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The average latency in milli seconds for write operations on this snapshot."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 11 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsIscsiReadWriteCmdsReceived  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of iscsi read/write commands received for operations on this volume. 
 | 
						|
        This object is a 64-bit version of eqliscsiVolumeStatsIscsiREadWriteCmdsReceived."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 12 }
 | 
						|
 | 
						|
eqliscsiSnapAccumulatedStatsIscsiTotalQD  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "A 64-bit counter that is incremented by the current number of outstanding iSCSI IO
 | 
						|
        operations each time an iSCSI IO is received by the target.  The iSCSI IO operations include
 | 
						|
        both reads and writes.  This counter when divided by the total number of iSCSI IO operations
 | 
						|
        provides the average queue depth.
 | 
						|
        This object is a 64 bit version of eqliscsiVolumeStatsIscsiReadWriteCmdsCompleted."
 | 
						|
::= { eqliscsiSnapAccumulatedStatisticsEntry 13 }
 | 
						|
 | 
						|
--***********************************************************************************
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteAdminAccountTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeReplSiteAdminAccountEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Admin Account Replication Site Table.
 | 
						|
                     This table contains a list of privilege matchings of administrative
 | 
						|
                     accounts and the replication sites those administrators have access to."
 | 
						|
    ::=    { eqliscsiTarget 58 }     
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteAdminAccountEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeReplSiteAdminAccountEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing mapping of administrative accounts and their
 | 
						|
                     replication site access."
 | 
						|
    INDEX           { eqlGroupId, eqliscsiVolumeReplSiteIndex, eqlStorageGroupAdminAccountIndex }
 | 
						|
    ::=   { eqliscsiVolumeReplSiteAdminAccountTable 1}
 | 
						|
 | 
						|
EqliscsiVolumeReplSiteAdminAccountEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeReplSiteAdminAccountRowStatus      RowStatus,
 | 
						|
        eqliscsiVolumeReplSiteAdminAccountQuotaType      ReplSiteQuotaType,
 | 
						|
        eqliscsiVolumeReplSiteAdminAccountQuota          Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteAdminAccountRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiVolumeReplSiteAdminAccountEntry 1 }  
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteAdminAccountQuotaType OBJECT-TYPE
 | 
						|
    SYNTAX         ReplSiteQuotaType
 | 
						|
    MAX-ACCESS     read-create
 | 
						|
    STATUS         current
 | 
						|
    DESCRIPTION    "The format of the adminQuota value:
 | 
						|
                        0 - Unlimited quota,
 | 
						|
                        1 - Size in Megabytes.
 | 
						|
                    This field applies only to Volume Administrators."
 | 
						|
    ::=  {  eqliscsiVolumeReplSiteAdminAccountEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeReplSiteAdminAccountQuota OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the storage space quota (in MB) for a 
 | 
						|
                     Volume Administrator in the delegated space at this replication site.  
 | 
						|
                     This field applies only to Volume Administrators."  
 | 
						|
    ::= { eqliscsiVolumeReplSiteAdminAccountEntry 3 }  
 | 
						|
 | 
						|
--*************************************************************************************
 | 
						|
eqlLdapLoginAccessReplSiteTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqlLdapLoginAccessReplSiteEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Group LDAP login access table. 
 | 
						|
                     For LDAP login access configured with volume-admin privilege stores 
 | 
						|
                     the replication sites, volume-admin has access to." 
 | 
						|
    ::=  {  eqliscsiTarget 59 }
 | 
						|
 | 
						|
eqlLdapLoginAccessReplSiteEntry OBJECT-TYPE
 | 
						|
    SYNTAX          EqlLdapLoginAccessReplSiteEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing the configuration for the LDAP 
 | 
						|
                     login access replication quotas."
 | 
						|
    INDEX           { eqlGroupId, eqlLdapLoginAccessType, eqlLdapLoginAccessName, eqliscsiVolumeReplSiteIndex }
 | 
						|
    ::=    { eqlLdapLoginAccessReplSiteTable 1 }
 | 
						|
 | 
						|
EqlLdapLoginAccessReplSiteEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqlLdapLoginAccessReplSiteQuotaType     ReplSiteQuotaType,
 | 
						|
        eqlLdapLoginAccessReplSiteQuota         Unsigned32,
 | 
						|
        eqlLdapLoginAccessReplSiteRowStatus     RowStatus
 | 
						|
        }
 | 
						|
 | 
						|
eqlLdapLoginAccessReplSiteQuotaType OBJECT-TYPE
 | 
						|
    SYNTAX         ReplSiteQuotaType 
 | 
						|
    MAX-ACCESS     read-create
 | 
						|
    STATUS         current
 | 
						|
    DESCRIPTION    "The format of the adminQuota value:
 | 
						|
                        0 - Unlimited quota,
 | 
						|
                        1 - Size in Megabytes.
 | 
						|
                    This field applies only to Volume Administrators."
 | 
						|
    ::=  {  eqlLdapLoginAccessReplSiteEntry 1 }
 | 
						|
 | 
						|
eqlLdapLoginAccessReplSiteQuota OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the storage space quota (in MB) for a 
 | 
						|
                     Volume Administrator in the storage Repl Site.  This field 
 | 
						|
                     applies only to Volume Administrators."  
 | 
						|
    ::= { eqlLdapLoginAccessReplSiteEntry 2 }
 | 
						|
 | 
						|
eqlLdapLoginAccessReplSiteRowStatus OBJECT-TYPE  
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::= { eqlLdapLoginAccessReplSiteEntry 3 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplExtensionTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplExtensionEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent "  
 | 
						|
    ::=  {  eqliscsiTarget 60 }    
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplExtensionEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplExtensionEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume-specific information 
 | 
						|
                     required for configuring synchronous replication"
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplExtensionTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplExtensionEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplExtRowStatus              RowStatus,
 | 
						|
        eqliscsiVolumeSyncReplExtSyncReplLocalMemberId  Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplExtSyncReplIndex          Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplExtIntTargetIscsiName     OCTET STRING
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplExtRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used to indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiVolumeSyncReplExtensionEntry 1 }  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplExtSyncReplLocalMemberId  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the first part of a unique index for identifing a synchronous replication relationship between volumes."  
 | 
						|
    ::=  {eqliscsiVolumeSyncReplExtensionEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplExtSyncReplIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the second part of a unique index for identifing a synchronous replication relationship between volumes."  
 | 
						|
    ::=  {eqliscsiVolumeSyncReplExtensionEntry 3 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplExtIntTargetIscsiName OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (0..223))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the iSCSI target name that is internally used for
 | 
						|
                     a syncronous replication volume."  
 | 
						|
    ::=  { eqliscsiVolumeSyncReplExtensionEntry 4  }  
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent "  
 | 
						|
    ::=  {  eqliscsiTarget 61 }    
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing configuration information for replicating an active
 | 
						|
                     volume to a standby "
 | 
						|
    INDEX           { eqliscsiVolumeSyncReplLocalMemberId , eqliscsiVolumeSyncReplIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplRowStatus               RowStatus,
 | 
						|
        eqliscsiVolumeSyncReplLocalMemberId           Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplIndex                   Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplPaused                  TruthValue
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used to indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiVolumeSyncReplEntry 1 }  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplLocalMemberId  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the first part of a unique index for identifing a synchronous replication relationship between volumes."  
 | 
						|
    ::=  {eqliscsiVolumeSyncReplEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the second part of a unique index for identifing a synchronous replication relationship between volumes."  
 | 
						|
    ::=  {eqliscsiVolumeSyncReplEntry 3 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplPaused   OBJECT-TYPE
 | 
						|
   SYNTAX            TruthValue
 | 
						|
   MAX-ACCESS        read-write
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "Indicates whether IO forwarding to the replication standby volume is allowed (false) or halted (true)."
 | 
						|
   DEFVAL            {false}
 | 
						|
   ::=   {eqliscsiVolumeSyncReplEntry 4 }
 | 
						|
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplPeerTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplPeerEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic "  
 | 
						|
    ::=  {  eqliscsiTarget 62 }    
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplPeerEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplPeerEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing peer volume information for synchronous volume replication.
 | 
						|
                     The first 2 indexes identify the volume, and the second 2 indexes identify the peer."
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeSyncReplPeerLocalMemberId, eqliscsiVolumeSyncReplPeerVolIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplPeerTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplPeerEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplPeerLocalMemberId   Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplPeerVolIndex        Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplPeerPsvId           OCTET STRING
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplPeerLocalMemberId  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the first part of a unique index for identifing the
 | 
						|
                     peer of the synchronous replication volume."
 | 
						|
    ::=  {eqliscsiVolumeSyncReplPeerEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplPeerVolIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the second part of a unique index for identifing the
 | 
						|
                     peer of the synchronous replication volume."
 | 
						|
    ::=  {eqliscsiVolumeSyncReplPeerEntry 2 }
 | 
						|
  
 | 
						|
eqliscsiVolumeSyncReplPeerPsvId  OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "If non-zero, the value represents the PsvId of the peer of the
 | 
						|
                     synchronous replication volume."
 | 
						|
    DEFVAL          { "" }
 | 
						|
    ::= { eqliscsiVolumeSyncReplPeerEntry 3 }
 | 
						|
 | 
						|
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplStatusTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION      "EqualLogic-Dynamic "
 | 
						|
    ::=  {  eqliscsiTarget 63 }    
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "Synchronous replication status information"
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplStatusEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplStatusSyncStatus                INTEGER,
 | 
						|
	eqliscsiVolumeSyncReplStatusUnreplicatedChanges       INTEGER,
 | 
						|
	eqliscsiVolumeSyncReplStatusTotalTxDataMB             Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplStatusRemainingTxDataMB         Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplStatusSyncStatus  OBJECT-TYPE      
 | 
						|
    SYNTAX           INTEGER     {
 | 
						|
                        in-sync(1),
 | 
						|
                        out-of-sync(2),
 | 
						|
                        out-of-sync-due-to-paused(3),
 | 
						|
                        out-of-sync-due-to-snap-reserve-met(4),
 | 
						|
                        out-of-sync-due-to-member-offline(5),
 | 
						|
                        out-of-sync-due-to-no-pool-space-for-auto-grow(6),
 | 
						|
                        out-of-sync-due-to-alt-pool-lost-blocks(7)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether the volume is in sync"
 | 
						|
    ::=  {eqliscsiVolumeSyncReplStatusEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplStatusUnreplicatedChanges  OBJECT-TYPE      
 | 
						|
    SYNTAX           INTEGER     {
 | 
						|
                        yes(1),
 | 
						|
                        no(2),
 | 
						|
                        unknown(3)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether unreplicated changes exist for this volume."
 | 
						|
    ::=  {eqliscsiVolumeSyncReplStatusEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplStatusTotalTxDataMB OBJECT-TYPE      
 | 
						|
    SYNTAX           Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field represents the amount of total changes since last in sync."
 | 
						|
    ::=  { eqliscsiVolumeSyncReplStatusEntry 3  }  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplStatusRemainingTxDataMB OBJECT-TYPE      
 | 
						|
    SYNTAX           Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field represents the amount of remaining changes which need to be replicated."
 | 
						|
    ::=  { eqliscsiVolumeSyncReplStatusEntry 4  }  
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplVirtualEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION      "EqualLogic-Dynamic Sync Replication Virtual Volume Table.
 | 
						|
                      This table contains a list of sync replication virtual volumes in a group and their attributes."
 | 
						|
    ::=  {  eqliscsiTarget 64 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplVirtualEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing sync replication virtual volume info."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplVirtualTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplVirtualEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplVirtualAccessType          INTEGER,  
 | 
						|
        eqliscsiVolumeSyncReplVirtualAdminStatus         INTEGER,
 | 
						|
        eqliscsiVolumeSyncReplVirtualMultInitiator       INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualAccessType OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                    read-write(1),
 | 
						|
                    read-only (2)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies access rights for the volume.
 | 
						|
                     The volume can be either read-write or read-only. The default is read-write."  
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=   { eqliscsiVolumeSyncReplVirtualEntry 1}    
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualAdminStatus  OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        online(1),
 | 
						|
                        offline(2),
 | 
						|
                        online-lost-cached-blocks(3)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies if the volume is set to online or offline by
 | 
						|
                     the administrator. If a volume is offline, it cannot be accessed
 | 
						|
                     by iscsi initiators."
 | 
						|
    ::=  {eqliscsiVolumeSyncReplVirtualEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualMultInitiator  OBJECT-TYPE
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        allowed(0),
 | 
						|
                        not-allowed(1)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Specifies if the access from multiple initiators is 
 | 
						|
                     allowed for the volume."
 | 
						|
    DEFVAL          { 1 }
 | 
						|
    ::=   { eqliscsiVolumeSyncReplVirtualEntry 3}
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplVirtualStatusEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION      "EqualLogic-Dynamic Sync Replication Virtual Volume Table.
 | 
						|
                      This table contains a list of sync replication virtual volumes in a group and their stats."
 | 
						|
    ::=  {  eqliscsiTarget 65 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplVirtualStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing sync replication virtual volume stats."
 | 
						|
    AUGMENTS        { eqliscsiVolumeSyncReplVirtualEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplVirtualStatusTable 1}
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplVirtualStatusEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatusReservedSpace       Integer32,      
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatusReservedSpaceAvail  Integer32,
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatusNumSnapshots        Integer32,
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatusOperStatus          INTEGER,
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatusConnections         Integer32,
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatusAllocatedSpace      Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatusVolReserveSpace     Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatusExtConnections      Integer32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusReservedSpace OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies how many MB of space is reserved for
 | 
						|
                     snapshots of this volume.
 | 
						|
                     This is a dynamic value, it is not Administrator setable."
 | 
						|
    ::=   { eqliscsiVolumeSyncReplVirtualStatusEntry 1}  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusReservedSpaceAvail OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies how many MB of reserved space that is unused
 | 
						|
                     by the snapshots."
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::=   { eqliscsiVolumeSyncReplVirtualStatusEntry 2 } 
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusNumSnapshots  OBJECT-TYPE
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Indicates the number of snapshots that the system is 
 | 
						|
                     maintaining on the specified volume"
 | 
						|
    ::=   { eqliscsiVolumeSyncReplVirtualStatusEntry 3 } 
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusOperStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        available(1),
 | 
						|
                        not-available(2),
 | 
						|
                        not-available-due-to-snap-reserve-met(3),
 | 
						|
                        not-available-due-to-members-offline(4),
 | 
						|
                        not-available-due-to-lost-cached-blocks(5),
 | 
						|
                        not-available-due-to-thin-max-growth-met(6),
 | 
						|
                        not-available-due-to-nospace-for-auto-grow(7),
 | 
						|
                        not-available-due-to-missing-pages(8),
 | 
						|
                        not-available-due-to-syncrep(9),
 | 
						|
                        available-no-new-connections(10),
 | 
						|
                        not-available-due-to-internal-error(11)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the current operational status of the 
 | 
						|
                     volume."
 | 
						|
    ::= {   eqliscsiVolumeSyncReplVirtualStatusEntry 4 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusConnections OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
            "
 | 
						|
             The value of this object represents number of active iscsi 
 | 
						|
             connections to this volume. It MUST match with the number of rows 
 | 
						|
             for this particular iscsiNode in iscsiConnectionAttributesTable.
 | 
						|
            "
 | 
						|
    ::= {   eqliscsiVolumeSyncReplVirtualStatusEntry 5 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusAllocatedSpace  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "
 | 
						|
                     The value of this object represents the actual materialized pages for this volume. 
 | 
						|
                    "
 | 
						|
    ::=   {eqliscsiVolumeSyncReplVirtualStatusEntry 6 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusVolReserveSpace  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "
 | 
						|
                     The value of this object represents the pages reserved for this volume. 
 | 
						|
                    "
 | 
						|
    ::=   {eqliscsiVolumeSyncReplVirtualStatusEntry 7 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatusExtConnections OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
            "
 | 
						|
             The value of this object represents number of active iscsi 
 | 
						|
             connections to this volume, not counting EQL generated connections.
 | 
						|
            "
 | 
						|
    ::= {   eqliscsiVolumeSyncReplVirtualStatusEntry 8 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatisticsTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVolumeSyncReplVirtualStatisticsEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Sync Replication Virtual Volume Table.
 | 
						|
                     This table contains a list of sync replication virtual volumes in a group and their statistics." 
 | 
						|
    ::=    { eqliscsiTarget 66 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatisticsEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplVirtualStatisticsEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing sync replication virtual volume statistics."
 | 
						|
    AUGMENTS        { eqliscsiVolumeSyncReplVirtualEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplVirtualStatisticsTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplVirtualStatisticsEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatsTxData             Counter64,
 | 
						|
        eqliscsiVolumeSyncReplVirtualStatsRxData             Counter64
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatsTxData OBJECT-TYPE
 | 
						|
    SYNTAX         Counter64
 | 
						|
    UNITS         "octets"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of data octets that were transmitted by
 | 
						|
        the local iSCSI node."
 | 
						|
::= { eqliscsiVolumeSyncReplVirtualStatisticsEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplVirtualStatsRxData OBJECT-TYPE
 | 
						|
    SYNTAX         Counter64
 | 
						|
    UNITS         "octets"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of data octets that were received by
 | 
						|
        the local iSCSI node."
 | 
						|
::= { eqliscsiVolumeSyncReplVirtualStatisticsEntry 2 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVsrVirtualSyncReplStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiVsrVirtualSyncReplStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Sync Replication Virtual Volume Sync Repl Status Table.
 | 
						|
                     This table contains a list of sync replication virtual volumes in a group and their sync replication status." 
 | 
						|
    ::=    { eqliscsiTarget 67 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiVsrVirtualSyncReplStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVsrVirtualSyncReplStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing sync replication virtual volume sync replication status."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVsrVirtualSyncReplStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiVsrVirtualSyncReplStatusEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiVsrVirtualSyncReplStatusSyncStatus                INTEGER,
 | 
						|
        eqliscsiVsrVirtualSyncReplStatusUnreplicatedChanges       INTEGER,
 | 
						|
        eqliscsiVsrVirtualSyncReplStatusTotalTxDataMB             Unsigned32,
 | 
						|
        eqliscsiVsrVirtualSyncReplStatusRemainingTxDataMB         Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVsrVirtualSyncReplStatusSyncStatus  OBJECT-TYPE      
 | 
						|
    SYNTAX           INTEGER     {
 | 
						|
                        in-sync(1),
 | 
						|
                        out-of-sync(2),
 | 
						|
                        out-of-sync-due-to-paused(3),
 | 
						|
                        out-of-sync-due-to-snap-reserve-met(4),
 | 
						|
                        out-of-sync-due-to-member-offline(5),
 | 
						|
                        out-of-sync-due-to-no-pool-space-for-auto-grow(6),
 | 
						|
                        out-of-sync-due-to-alt-pool-lost-blocks(7)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether the volume is in sync."
 | 
						|
    ::=  {eqliscsiVsrVirtualSyncReplStatusEntry 1 }
 | 
						|
 | 
						|
eqliscsiVsrVirtualSyncReplStatusUnreplicatedChanges  OBJECT-TYPE      
 | 
						|
    SYNTAX           INTEGER     {
 | 
						|
                        yes(1),
 | 
						|
                        no(2),
 | 
						|
                        unknown(3)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether unreplicated changes exist for this volume."
 | 
						|
    ::=  {eqliscsiVsrVirtualSyncReplStatusEntry 2 }
 | 
						|
 | 
						|
eqliscsiVsrVirtualSyncReplStatusTotalTxDataMB OBJECT-TYPE      
 | 
						|
    SYNTAX           Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field represents the amount of total changes since last in sync."
 | 
						|
    ::=  { eqliscsiVsrVirtualSyncReplStatusEntry 3  }  
 | 
						|
 | 
						|
eqliscsiVsrVirtualSyncReplStatusRemainingTxDataMB OBJECT-TYPE      
 | 
						|
    SYNTAX           Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field represents the amount of remaining changes which need to be replicated."
 | 
						|
    ::=  { eqliscsiVsrVirtualSyncReplStatusEntry 4  }  
 | 
						|
 | 
						|
--**************************************************************************
 | 
						|
 | 
						|
eqliscsiSyncReplAfoStateTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiSyncReplAfoStateEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Equalogic-member local AFO state"
 | 
						|
    ::= { eqliscsiTarget  68 }
 | 
						|
 | 
						|
eqliscsiSyncReplAfoStateEntry OBJECT-TYPE
 | 
						|
    SYNTAX          EqliscsiSyncReplAfoStateEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION	    "An member local entry (row) containing a volume's AFO state for synchronous replication
 | 
						|
                     The first 4 indexes identify the volume with the lowest psvid, and 
 | 
						|
                     the second 4 indexes identify the volume with the highest psvid."
 | 
						|
    INDEX           { eqliscsiVolumeLowPsvId0 , eqliscsiVolumeLowPsvId1, eqliscsiVolumeLowPsvId2 , eqliscsiVolumeLowPsvId3,
 | 
						|
                      eqliscsiVolumeHighPsvId0 , eqliscsiVolumeHighPsvId1, eqliscsiVolumeHighPsvId2 , eqliscsiVolumeHighPsvId3 }
 | 
						|
    ::= { eqliscsiSyncReplAfoStateTable 1 }
 | 
						|
 | 
						|
EqliscsiSyncReplAfoStateEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiSyncReplAfoSeqNum                       Unsigned32,
 | 
						|
        eqliscsiSyncReplAfoState                        Unsigned32,
 | 
						|
        eqliscsiSyncReplAfoGrpLeadUuid                  OCTET STRING
 | 
						|
    }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSyncReplAfoSeqNum  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the sequence number for the record"
 | 
						|
    ::=  {eqliscsiSyncReplAfoStateEntry 1 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSyncReplAfoState  OBJECT-TYPE      
 | 
						|
    SYNTAX           Unsigned32 
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the current AFO state"
 | 
						|
    ::=  {eqliscsiSyncReplAfoStateEntry 2 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSyncReplAfoGrpLeadUuid  OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This value represents the UUID of the Group lead that wrote this record"
 | 
						|
    ::= { eqliscsiSyncReplAfoStateEntry 3 }
 | 
						|
 | 
						|
--**************************************************************************
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplActivePoolTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolCollectionSyncReplActivePoolEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      This table maintains the list of pool configuration for each sync-repl collection.
 | 
						|
      "
 | 
						|
::= { eqliscsiTarget 69 }
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplActivePoolEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolCollectionSyncReplActivePoolEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "An entry in the table."
 | 
						|
    INDEX           { eqliscsiVolCollectionIndex }
 | 
						|
::= { eqliscsiVolCollectionSyncReplActivePoolTable 1 }
 | 
						|
 | 
						|
EqliscsiVolCollectionSyncReplActivePoolEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolCollectionSyncReplActivePoolRowStatus           RowStatus,
 | 
						|
   eqliscsiVolCollectionSyncReplActivePoolIndex               Unsigned32,
 | 
						|
   eqliscsiVolCollectionSyncReplActivePoolFlags               BITS    
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplActivePoolRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiVolCollectionSyncReplActivePoolEntry 1 }  
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplActivePoolIndex OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the unique index of the pool serving 
 | 
						|
                     as the active pool in a sync-replication collection"
 | 
						|
    DEFVAL          { 0 }
 | 
						|
    ::= { eqliscsiVolCollectionSyncReplActivePoolEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplActivePoolFlags OBJECT-TYPE
 | 
						|
    SYNTAX          BITS {
 | 
						|
                    syncReplDiscardActiveChanges(0), -- Discard the active volume changes since going out of sync - set but not retained
 | 
						|
                    syncReplForceFailover(1),        -- Forces a collection failover to the SyncAlternate volume pool - set but not retained
 | 
						|
                    flag2(2),
 | 
						|
                    flag3(3),
 | 
						|
                    flag4(4),
 | 
						|
                    flag5(5),
 | 
						|
                    flag6(6),
 | 
						|
                    flag7(7),
 | 
						|
                    flag8(8),
 | 
						|
                    flag9(9),
 | 
						|
                    flag10(10),
 | 
						|
                    flag11(11),
 | 
						|
                    flag12(12),
 | 
						|
                    flag13(13),
 | 
						|
                    flag14(14),
 | 
						|
                    flag15(15),
 | 
						|
                    flag16(16),
 | 
						|
                    flag17(17),
 | 
						|
                    flag18(18),
 | 
						|
                    flag19(19),
 | 
						|
                    flag20(20),
 | 
						|
                    flag21(21),
 | 
						|
                    flag22(22),
 | 
						|
                    flag23(23),
 | 
						|
                    flag24(24),
 | 
						|
                    flag25(25),
 | 
						|
                    flag26(26),
 | 
						|
                    flag27(27),
 | 
						|
                    flag28(28),
 | 
						|
                    flag29(29),
 | 
						|
                    flag30(30),
 | 
						|
                    flag31(31)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This fields defines the common place holder for sync-replication volume collection.  The flags must be of type
 | 
						|
                    enable(1) or disable(0), and the default will always be disable(0)."
 | 
						|
    DEFVAL          { {} }
 | 
						|
    ::= { eqliscsiVolCollectionSyncReplActivePoolEntry 3 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplStatusTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolCollectionSyncReplStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION      "EqualLogic-Dynamic "
 | 
						|
    ::=  {  eqliscsiTarget 70 }    
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolCollectionSyncReplStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "Synchronous replication status information"
 | 
						|
    INDEX           { eqliscsiVolCollectionIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolCollectionSyncReplStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiVolCollectionSyncReplStatusEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolCollectionSyncReplStatusSyncStatus                INTEGER,
 | 
						|
	eqliscsiVolCollectionSyncReplStatusUnreplicatedChanges       INTEGER,
 | 
						|
	eqliscsiVolCollectionSyncReplStatusTotalTxDataMB             Unsigned32,
 | 
						|
        eqliscsiVolCollectionSyncReplStatusRemainingTxDataMB         Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplStatusSyncStatus  OBJECT-TYPE      
 | 
						|
    SYNTAX           INTEGER     {
 | 
						|
                        in-sync(1),
 | 
						|
                        out-of-sync(2)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether the collection is in sync"
 | 
						|
    ::=  {eqliscsiVolCollectionSyncReplStatusEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplStatusUnreplicatedChanges  OBJECT-TYPE      
 | 
						|
    SYNTAX           INTEGER     {
 | 
						|
                        yes(1),
 | 
						|
                        no(2),
 | 
						|
                        unknown(3)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies whether unreplicated changes exist for this collection"
 | 
						|
    ::=  {eqliscsiVolCollectionSyncReplStatusEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplStatusTotalTxDataMB OBJECT-TYPE      
 | 
						|
    SYNTAX           Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field represents the amount of total changes since last in sync for this collection"
 | 
						|
    ::=  { eqliscsiVolCollectionSyncReplStatusEntry 3  }  
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplStatusRemainingTxDataMB OBJECT-TYPE      
 | 
						|
    SYNTAX           Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field represents the amount of remaining changes which need to be replicated for this collection"
 | 
						|
    ::=  { eqliscsiVolCollectionSyncReplStatusEntry 4  }  
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplIndexVolumesTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplIndexVolumesEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Sync replication index volumes table.  Provides relationships between
 | 
						|
                     sync replication indexes and all the volumes that are associated with that index."  
 | 
						|
    ::=  {  eqliscsiTarget 71 }    
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplIndexVolumesEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplIndexVolumesEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume information for synchronous replication access/alternate
 | 
						|
                     pairs.  The first two parts of the index identify the sync repl index of the pair, and the
 | 
						|
                     second two parts of the index identify the volume."
 | 
						|
    INDEX           { eqliscsiVolumeSyncReplLocalMemberId, eqliscsiVolumeSyncReplIndex, eqliscsiLocalMemberId, eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplIndexVolumesTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplIndexVolumesEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplIndexVolumesPsvId           OCTET STRING
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplIndexVolumesPsvId  OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "If non-zero, the value represents the PsvId of the peer of the
 | 
						|
                     synchronous replication volume."
 | 
						|
    DEFVAL          { "" }
 | 
						|
    ::= { eqliscsiVolumeSyncReplIndexVolumesEntry 1 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplSyncActiveOfflineTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplSyncActiveOfflineEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic"  
 | 
						|
    ::=  {  eqliscsiTarget 72 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplSyncActiveOfflineEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplSyncActiveOfflineEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume-specific information
 | 
						|
                     used to set the identified Synchronous Replication
 | 
						|
                     volume offline."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplSyncActiveOfflineTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplSyncActiveOfflineEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplSyncActiveOffline                TruthValue
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplSyncActiveOffline OBJECT-TYPE      
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-write      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used to take the SyncActive volume
 | 
						|
                     offline.  This field is read-write."
 | 
						|
    DEFVAL          { false }
 | 
						|
    ::=  { eqliscsiVolumeSyncReplSyncActiveOfflineEntry 1  }  
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiDeletedVolumeInfoTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiDeletedVolumeInfoEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent "  
 | 
						|
    ::=  {  eqliscsiTarget 73 }
 | 
						|
 | 
						|
eqliscsiDeletedVolumeInfoEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiDeletedVolumeInfoEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing information about a
 | 
						|
                     volume at the time it was deleted, used to restore 
 | 
						|
                     a deleted volume to its original state (on un-delete), 
 | 
						|
                     or to purge volume permanently to create free space."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiDeletedVolumeInfoTable 1 }     
 | 
						|
 | 
						|
EqliscsiDeletedVolumeInfoEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiDeletedVolumeInfoRowStatus              RowStatus,
 | 
						|
        eqliscsiDeletedVolumeInfoOriginalName           UTFString,
 | 
						|
        eqliscsiDeletedVolumeInfoOriginalType           INTEGER,  
 | 
						|
        eqliscsiDeletedVolumeFlags                      BITS,
 | 
						|
        eqliscsiDeletedVolumeInfoDeleteDate             Counter32,
 | 
						|
        eqliscsiDeletedVolumeThinWarnPercentage         Unsigned32,
 | 
						|
        eqliscsiDeletedVolumeThinMaxGrowPercentage      Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiDeletedVolumeInfoRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used to indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiDeletedVolumeInfoEntry 1 }  
 | 
						|
 | 
						|
eqliscsiDeletedVolumeInfoOriginalName OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (1..64))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is the original name of the volume at the time
 | 
						|
                     it was deleted.  A unique name is created for a deleted
 | 
						|
                     volume so that it does not collide with visible volumes.
 | 
						|
                     The volume is restored with this original name if possible."
 | 
						|
    ::=  { eqliscsiDeletedVolumeInfoEntry 2 }  
 | 
						|
 | 
						|
eqliscsiDeletedVolumeInfoOriginalType OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                    classic(1),
 | 
						|
                    thin-provisioned(2),
 | 
						|
                    snapshot(3)
 | 
						|
    }     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the volume type at the time it was deleted.   Volumes
 | 
						|
                     are converted to thin provisioned when they are deleted in order to consume
 | 
						|
                     as little free space as possible.  They are converted back to this type 
 | 
						|
                     when they are restored."  
 | 
						|
    ::= { eqliscsiDeletedVolumeInfoEntry 3 }
 | 
						|
 | 
						|
eqliscsiDeletedVolumeFlags OBJECT-TYPE
 | 
						|
    SYNTAX          BITS {
 | 
						|
                    replicaset(0),          -- Volume was the latest in a replicaset
 | 
						|
                    failback(1),            -- Volume was a failback 
 | 
						|
                    recovery(2),            -- Volume was a recovery volume
 | 
						|
                    syncrep(3),             -- Volume was originally sync-repped
 | 
						|
                    template(4),            -- Volume was a template
 | 
						|
                    thinClone(5),           -- Volume was a thin clone
 | 
						|
                    flag6(6),
 | 
						|
                    flag7(7),
 | 
						|
                    flag8(8),
 | 
						|
                    flag9(9),
 | 
						|
                    flag10(10),
 | 
						|
                    flag11(11),
 | 
						|
                    flag12(12),
 | 
						|
                    flag13(13),
 | 
						|
                    flag14(14),
 | 
						|
                    flag15(15),
 | 
						|
                    flag16(16),
 | 
						|
                    flag17(17),
 | 
						|
                    flag18(18),
 | 
						|
                    flag19(19),
 | 
						|
                    flag20(20),
 | 
						|
                    flag21(21),
 | 
						|
                    flag22(22),
 | 
						|
                    flag23(23),
 | 
						|
                    flag24(24),
 | 
						|
                    flag25(25),
 | 
						|
                    flag26(26),
 | 
						|
                    flag27(27),
 | 
						|
                    flag28(28),
 | 
						|
                    flag29(29),
 | 
						|
                    flag30(30),
 | 
						|
                    flag31(31)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This bitfield contains volume modifiers or types that a volume originally
 | 
						|
                     had at the time it was deleted.  Deleted volumes are converted to thin-provisioned
 | 
						|
                     while recoverable, these fields help to restore a volume to its original state." 
 | 
						|
    ::= { eqliscsiDeletedVolumeInfoEntry 4 }
 | 
						|
 | 
						|
eqliscsiDeletedVolumeInfoDeleteDate OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the deleted time for a volume.
 | 
						|
                     Time is represented as the time in seconds since 00:00:00 UTC, 1970-01-01.
 | 
						|
                     It is used to determine the oldest deleted volume when it is necessary to
 | 
						|
                     trim back volumes to create free space." 
 | 
						|
    ::= { eqliscsiDeletedVolumeInfoEntry 5 }
 | 
						|
 | 
						|
eqliscsiDeletedVolumeThinWarnPercentage OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is the original thin warning percentage for the volume at the
 | 
						|
                     time it was deleted." 
 | 
						|
    ::= { eqliscsiDeletedVolumeInfoEntry 6 }
 | 
						|
 | 
						|
eqliscsiDeletedVolumeThinMaxGrowPercentage OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32  
 | 
						|
    MAX-ACCESS      read-only     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is the original thin max grow percentage for the volume at the
 | 
						|
                     time it was deleted." 
 | 
						|
    ::= { eqliscsiDeletedVolumeInfoEntry 7 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplActivePeerEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      This table maintains the volume index of the volume in
 | 
						|
      the active pool for a sync-repl volume.
 | 
						|
     "
 | 
						|
    ::=  {  eqliscsiTarget 74 }    
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplActivePeerEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing active peer volume information for synchronous volume replication."
 | 
						|
    INDEX           { eqliscsiVolumeSyncReplLocalMemberId , eqliscsiVolumeSyncReplIndex }
 | 
						|
    ::=   { eqliscsiVolumeSyncReplActivePeerTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplActivePeerEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplActivePeerRowStatus       RowStatus,
 | 
						|
        eqliscsiVolumeSyncReplActivePeerLocalMemberId   Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplActivePeerVolIndex        Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplActivePeerFlags           BITS    
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::= { eqliscsiVolumeSyncReplActivePeerEntry 1 }  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerLocalMemberId  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the first part of a unique index for identifing the
 | 
						|
                     active peer of the synchronous replication volume."
 | 
						|
    ::=  {eqliscsiVolumeSyncReplActivePeerEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerVolIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the second part of a unique index for identifing the
 | 
						|
                     active peer of the synchronous replication volume."
 | 
						|
    ::=  {eqliscsiVolumeSyncReplActivePeerEntry 3 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerFlags OBJECT-TYPE
 | 
						|
    SYNTAX          BITS {
 | 
						|
                    syncReplDiscardActiveChanges(0), -- Discard the active volume changes since going out of sync - set but not retained
 | 
						|
                    syncReplForceFailover(1),        -- Forces a failover to the SyncAlternate volume - set but not retained
 | 
						|
                    flag2(2),
 | 
						|
                    flag3(3),
 | 
						|
                    flag4(4),
 | 
						|
                    flag5(5),
 | 
						|
                    flag6(6),
 | 
						|
                    flag7(7),
 | 
						|
                    flag8(8),
 | 
						|
                    flag9(9),
 | 
						|
                    flag10(10),
 | 
						|
                    flag11(11),
 | 
						|
                    flag12(12),
 | 
						|
                    flag13(13),
 | 
						|
                    flag14(14),
 | 
						|
                    flag15(15),
 | 
						|
                    flag16(16),
 | 
						|
                    flag17(17),
 | 
						|
                    flag18(18),
 | 
						|
                    flag19(19),
 | 
						|
                    flag20(20),
 | 
						|
                    flag21(21),
 | 
						|
                    flag22(22),
 | 
						|
                    flag23(23),
 | 
						|
                    flag24(24),
 | 
						|
                    flag25(25),
 | 
						|
                    flag26(26),
 | 
						|
                    flag27(27),
 | 
						|
                    flag28(28),
 | 
						|
                    flag29(29),
 | 
						|
                    flag30(30),
 | 
						|
                    flag31(31)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field defines the common place holder for sync-replication volume.  The flags must be of type
 | 
						|
                    enable(1) or disable(0), and the default will always be disable(0)."
 | 
						|
    DEFVAL          { {} }
 | 
						|
    ::= { eqliscsiVolumeSyncReplActivePeerEntry 4 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerLookupTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolumeSyncReplActivePeerLookupEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic "  
 | 
						|
    ::=  {  eqliscsiTarget 75 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerLookupEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolumeSyncReplActivePeerLookupEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing active peer volume information for synchronous volume replication.
 | 
						|
                     The index identifies any peer, and the columns identify the active peer, or 0 if there is none."
 | 
						|
    INDEX           { eqliscsiLocalMemberId, eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolumeSyncReplActivePeerLookupTable 1}     
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplActivePeerLookupEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolumeSyncReplActivePeerLookupLocalMemberId   Unsigned32,
 | 
						|
        eqliscsiVolumeSyncReplActivePeerLookupVolIndex        Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerLookupLocalMemberId  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the first part of a unique index for identifing the
 | 
						|
                     active peer of the synchronous replication volume."
 | 
						|
    ::=  {eqliscsiVolumeSyncReplActivePeerLookupEntry 1 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplActivePeerLookupVolIndex  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the second part of a unique index for identifing the
 | 
						|
                     active peer of the synchronous replication volume."
 | 
						|
    ::=  {eqliscsiVolumeSyncReplActivePeerLookupEntry 2 }
 | 
						|
 | 
						|
--**************************************************************************
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplFailbackTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeSyncReplFailbackEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      This table maintains the list of underlying sync-repl volumes and if they can be used as
 | 
						|
      a sync-repl failback target.
 | 
						|
      "
 | 
						|
::= { eqliscsiTarget 76 }
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplFailbackEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeSyncReplFailbackEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "An entry in the sync-repl failback table."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
::= { eqliscsiVolumeSyncReplFailbackTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeSyncReplFailbackEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolumeSyncReplFailbackRowStatus               RowStatus,
 | 
						|
   eqliscsiVolumeSyncReplAllowFailback                   TruthValue
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplFailbackRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this table entry."  
 | 
						|
    ::= { eqliscsiVolumeSyncReplFailbackEntry 1 }  
 | 
						|
 | 
						|
eqliscsiVolumeSyncReplAllowFailback OBJECT-TYPE      
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-write      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used to indicate that this volume can be used as a
 | 
						|
                     failback target."
 | 
						|
    DEFVAL          { true }
 | 
						|
    ::=  { eqliscsiVolumeSyncReplFailbackEntry 2  }  
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplSyncActiveOfflineTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolCollectionSyncReplSyncActiveOfflineEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic"  
 | 
						|
    ::=  {  eqliscsiTarget 77 }
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplSyncActiveOfflineEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolCollectionSyncReplSyncActiveOfflineEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing pool-specific information used
 | 
						|
                     to set the identified Synchronous Replication pool offline."
 | 
						|
    INDEX           { eqliscsiVolCollectionIndex, eqlStoragePoolIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolCollectionSyncReplSyncActiveOfflineTable 1}     
 | 
						|
 | 
						|
EqliscsiVolCollectionSyncReplSyncActiveOfflineEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolCollectionSyncReplSyncActiveOffline                TruthValue
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolCollectionSyncReplSyncActiveOffline OBJECT-TYPE      
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-write      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used to take the collection SyncActive pool
 | 
						|
                     offline.  This field is read-write."
 | 
						|
    DEFVAL          { false }  
 | 
						|
    ::=  { eqliscsiVolCollectionSyncReplSyncActiveOfflineEntry 1  }  
 | 
						|
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiSyncReplStateTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiSyncReplStateEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Equalogic-member local syncrep state"
 | 
						|
    ::= { eqliscsiTarget  78 }
 | 
						|
 | 
						|
eqliscsiSyncReplStateEntry OBJECT-TYPE
 | 
						|
    SYNTAX          EqliscsiSyncReplStateEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An member local entry (row) containing a volume's synchronous replication state
 | 
						|
                     The first 4 indexes identify the volume with the lowest psvid, and 
 | 
						|
                     the second 4 indexes identify the volume with the highest psvid."
 | 
						|
    INDEX           { eqliscsiVolumeLowPsvId0 , eqliscsiVolumeLowPsvId1, eqliscsiVolumeLowPsvId2 , eqliscsiVolumeLowPsvId3,
 | 
						|
                      eqliscsiVolumeHighPsvId0 , eqliscsiVolumeHighPsvId1, eqliscsiVolumeHighPsvId2 , eqliscsiVolumeHighPsvId3 }
 | 
						|
    ::= { eqliscsiSyncReplStateTable 1 }
 | 
						|
 | 
						|
EqliscsiSyncReplStateEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiSyncReplStateSeqNum                       Unsigned32,
 | 
						|
        eqliscsiSyncReplStateState                        Unsigned32,
 | 
						|
        eqliscsiSyncReplStateGrpLeadUuid                  OCTET STRING
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiSyncReplStateSeqNum  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the sequence number for the record"
 | 
						|
    ::=  {eqliscsiSyncReplStateEntry 1 }
 | 
						|
 | 
						|
eqliscsiSyncReplStateState  OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field specifies the Sync Rep State for the volume"
 | 
						|
    ::=  {eqliscsiSyncReplStateEntry 2 }
 | 
						|
 | 
						|
eqliscsiSyncReplStateGrpLeadUuid  OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This value represents the UUID of the Group lead that wrote this record"
 | 
						|
    ::= { eqliscsiSyncReplStateEntry 3 }
 | 
						|
 | 
						|
--**************************************************************************          
 | 
						|
 | 
						|
eqliscsiVsrVirtualSyncReplSyncActiveOfflineTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVsrVirtualSyncReplSyncActiveOfflineEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic"  
 | 
						|
    ::=  {  eqliscsiTarget 79 }
 | 
						|
 | 
						|
eqliscsiVsrVirtualSyncReplSyncActiveOfflineEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVsrVirtualSyncReplSyncActiveOfflineEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume-specific information
 | 
						|
                     used to set the identified Synchronous Replication
 | 
						|
                     volume offline for a virtual volume."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVsrVirtualSyncReplSyncActiveOfflineTable 1}     
 | 
						|
 | 
						|
EqliscsiVsrVirtualSyncReplSyncActiveOfflineEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVsrVirtualSyncReplSyncActiveOffline                TruthValue
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVsrVirtualSyncReplSyncActiveOffline OBJECT-TYPE      
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used to get the SyncActive offline status
 | 
						|
                    for the sync-rep volume pair represented by the virtual
 | 
						|
                    volume.  This field is read-only, the value can only be
 | 
						|
                    set via the volume SyncActive offline table."
 | 
						|
    DEFVAL          { false }
 | 
						|
    ::=  { eqliscsiVsrVirtualSyncReplSyncActiveOfflineEntry 1  }  
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVsrCollectionSyncReplSyncActiveOfflineTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVsrCollectionSyncReplSyncActiveOfflineEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic"  
 | 
						|
    ::=  {  eqliscsiTarget 80 }
 | 
						|
 | 
						|
eqliscsiVsrCollectionSyncReplSyncActiveOfflineEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVsrCollectionSyncReplSyncActiveOfflineEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing pool-specific information used
 | 
						|
                     to read the identified Synchronous Replication pool offline."
 | 
						|
    INDEX           { eqliscsiVolCollectionIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVsrCollectionSyncReplSyncActiveOfflineTable 1 }     
 | 
						|
 | 
						|
EqliscsiVsrCollectionSyncReplSyncActiveOfflineEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVsrCollectionSyncReplSyncActiveOffline                TruthValue
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVsrCollectionSyncReplSyncActiveOffline OBJECT-TYPE      
 | 
						|
    SYNTAX          TruthValue
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used to get the SyncActive offline status
 | 
						|
                    for the sync-rep collection represented by the virtual
 | 
						|
                    collection  This field is read-only, the value can only be
 | 
						|
                    set via the volume SyncActive offline collection table."
 | 
						|
    DEFVAL          { false }
 | 
						|
    ::=  { eqliscsiVsrCollectionSyncReplSyncActiveOfflineEntry 1 }  
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolNameSecondaryIndexTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiVolNameSecondaryIndexEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic"  
 | 
						|
    ::=  {  eqliscsiTarget 81 }
 | 
						|
 | 
						|
eqliscsiVolNameSecondaryIndexEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiVolNameSecondaryIndexEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) which uses the eqliscsiVolumeName secondary key
 | 
						|
                     to lookup a eqliscsiVolumeName."
 | 
						|
    INDEX           { eqliscsiVolumeName, eqliscsiLocalMemberId, eqliscsiVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiVolNameSecondaryIndexTable 1}     
 | 
						|
 | 
						|
EqliscsiVolNameSecondaryIndexEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiVolNameSecondaryIndexRowStatus                RowStatus
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiVolNameSecondaryIndexRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is value of the RowStatus of the
 | 
						|
                     corresponding eqliscsiVolumeRowStatus volume"  
 | 
						|
 | 
						|
    ::=  { eqliscsiVolNameSecondaryIndexEntry 1  }  
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiSharedVolumeSetTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiSharedVolumeSetEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Table Volume set table.
 | 
						|
				     This table stores information about Shared Volume Sets in the PS-Group"
 | 
						|
 | 
						|
    ::=    { eqliscsiTarget 82 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeSetEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiSharedVolumeSetEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing shared volume set information."
 | 
						|
    INDEX	{ eqliscsiLocalMemberId , eqliscsiSharedVolumeSetIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiSharedVolumeSetTable 1}
 | 
						|
 | 
						|
EqliscsiSharedVolumeSetEntry ::= 
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiSharedVolumeSetIndex                    Unsigned32,
 | 
						|
        eqliscsiSharedVolumeSetRowStatus                RowStatus,
 | 
						|
        eqliscsiSharedVolumeSetPsvid                    OCTET STRING,        
 | 
						|
        eqliscsiSharedVolumeSetSectorSize               INTEGER,
 | 
						|
        eqliscsiSharedVolumeSetStorageBucketUUID        OCTET STRING,
 | 
						|
        eqliscsiSharedVolumeSharedVolumeSetBucket       EQL2PartRowPointerStr,
 | 
						|
        eqliscsiSharedVolumeSetBucketFullPolicy         INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiSharedVolumeSetIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32     
 | 
						|
    MAX-ACCESS      not-accessible     
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifing shared volume set."  
 | 
						|
    ::=   { eqliscsiSharedVolumeSetEntry 1}     
 | 
						|
 | 
						|
eqliscsiSharedVolumeSetRowStatus OBJECT-TYPE
 | 
						|
    SYNTAX          RowStatus
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field indicates whether the shared volume set is active or not."
 | 
						|
    ::= {eqliscsiSharedVolumeSetEntry 2}
 | 
						|
 | 
						|
 | 
						|
eqliscsiSharedVolumeSetPsvid OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     This field is for internal use only."  
 | 
						|
    ::=  { eqliscsiSharedVolumeSetEntry 3}
 | 
						|
 | 
						|
 | 
						|
eqliscsiSharedVolumeSetSectorSize OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        sector-size-512-bytes(0),
 | 
						|
                        sector-size-4096-bytes(1)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies, in bytes, the sector size all shared volumes in this shared volume set." 
 | 
						|
    DEFVAL          { sector-size-512-bytes }
 | 
						|
    ::=   { eqliscsiSharedVolumeSetEntry 4 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeSetStorageBucketUUID OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION    "EQL-SECONDARY-KEY
 | 
						|
                    A pointer to the parent storage bucket 
 | 
						|
                    that contains this shared volume set."
 | 
						|
    REFERENCE
 | 
						|
        "eqliscsiStorageBucketTable"
 | 
						|
   ::=   { eqliscsiSharedVolumeSetEntry 5 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeSharedVolumeSetBucket OBJECT-TYPE
 | 
						|
    SYNTAX        EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "A pointer to the parent storage bucket that contains this 
 | 
						|
         shared volume set. 
 | 
						|
         Note this is a redundant field the
 | 
						|
         StorageBucketUUID field stores the same information. 
 | 
						|
         But the UUID field will come out as soon we add the support 
 | 
						|
         so IOM can read this table through netmgtd."
 | 
						|
     ::=  { eqliscsiSharedVolumeSetEntry 6 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeSetBucketFullPolicy OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {                                                                        
 | 
						|
                        keep-online-fail-write-to-unallocated-pages(0),
 | 
						|
                        make-svs-offline(1)
 | 
						|
                        
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies how the firmware will handle the bucket full condition. 
 | 
						|
                     keep-online-fail-write-to-new-pages: Keep all the shared volumes
 | 
						|
                      in the shared volume set online, but fail all write to unallocated pages.
 | 
						|
                     make-svs-offline: Take all the shared volumes in the shared volume set offline." 
 | 
						|
    DEFVAL          { keep-online-fail-write-to-unallocated-pages }
 | 
						|
    ::=   { eqliscsiSharedVolumeSetEntry 7 }
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiSharedVolumeTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiSharedVolumeEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Table for storing shared volume set attributes that can frequently change.
 | 
						|
                    "
 | 
						|
    ::=    { eqliscsiTarget 83 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiSharedVolumeEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiSharedVolumeEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing status for shared volume the values 
 | 
						|
                     in this table are user configurable."
 | 
						|
    INDEX        { eqliscsiLocalMemberId , eqliscsiSharedVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiSharedVolumeTable 1}     
 | 
						|
 | 
						|
EqliscsiSharedVolumeEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        
 | 
						|
        eqliscsiSharedVolumeIndex                             Unsigned32,
 | 
						|
        eqliscsiSharedVolumeRowStatus                         RowStatus,
 | 
						|
        eqliscsiSharedVolumePsvid                             OCTET STRING,
 | 
						|
        eqliscsiSharedVolumeName                              UTFString,
 | 
						|
        eqliscsiSharedVolumeSize                              Integer32,                  
 | 
						|
        eqliscsiSharedVolumeCreatedAs                         VirtualVolumeCreatedAs,        
 | 
						|
        eqliscsiSharedVolumeIfSnapshotOrFastCloneMyParentVVol EQL2PartRowPointerStr,        
 | 
						|
        eqliscsiSharedVolumeSharedVolumeSet                   EQL2PartRowPointerStr,
 | 
						|
        eqliscsiSharedVolumeDescription                       UTFString,
 | 
						|
        eqliscsiSharedVolumeFlags                             BITS,
 | 
						|
        eqliscsiSharedVolumeSecondaryLunId                    Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiSharedVolumeIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a unique index for identifying a shared volume."
 | 
						|
    ::=   { eqliscsiSharedVolumeEntry 1}
 | 
						|
 | 
						|
eqliscsiSharedVolumeRowStatus  OBJECT-TYPE
 | 
						|
    SYNTAX          RowStatus
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::=   { eqliscsiSharedVolumeEntry 2}
 | 
						|
 | 
						|
 | 
						|
eqliscsiSharedVolumePsvid OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     This field is a unique universal identifier for this
 | 
						|
                     shared volume. This field is mostly for internal use only." 
 | 
						|
    ::=  { eqliscsiSharedVolumeEntry 3 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeName OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (1..64))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies a user friendly name for the shared volume.
 | 
						|
                     The name must be unique within a group.
 | 
						|
                     The name must not contain spaces or special characters.
 | 
						|
                     The name can be up to 64 characters in length. There is no default."
 | 
						|
    ::=  {  eqliscsiSharedVolumeEntry 4 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeSize OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    UNITS           "MB"  
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the volume size in MB. There is no default.
 | 
						|
                     Note: Volume size is round to a multiple of 15MB. All shared volumes 
 | 
						|
                     are thin provisioned so this value represents the advertized size 
 | 
						|
                     of the volume"
 | 
						|
    ::=   { eqliscsiSharedVolumeEntry 5 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSharedVolumeCreatedAs OBJECT-TYPE      
 | 
						|
    SYNTAX          VirtualVolumeCreatedAs
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies if the shared volume is set to online or offline by
 | 
						|
                     the administrator. If a volume is offline, it cannot be accessed
 | 
						|
                     by iscsi initiators."
 | 
						|
     DEFVAL      { stand-alone } 
 | 
						|
       ::=   { eqliscsiSharedVolumeEntry 6 } 
 | 
						|
 | 
						|
eqliscsiSharedVolumeIfSnapshotOrFastCloneMyParentVVol OBJECT-TYPE      
 | 
						|
    SYNTAX          EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     This field is only applicable to shared volumes that are created
 | 
						|
                     as snapshots. If snapshot shared volume, this field identifies 
 | 
						|
                     the parent." 
 | 
						|
    ::=  { eqliscsiSharedVolumeEntry 7 }
 | 
						|
  
 | 
						|
eqliscsiSharedVolumeSharedVolumeSet OBJECT-TYPE
 | 
						|
    SYNTAX        EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "A pointer to the corresponding Shared Volume Set that contains this 
 | 
						|
         shared volume."    
 | 
						|
     ::=  { eqliscsiSharedVolumeEntry 8 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSharedVolumeDescription OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-only    
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a descriptive string that provides details about the volume.
 | 
						|
                     The description can be up to 128 characters. There is no default value."  
 | 
						|
    ::=  {  eqliscsiSharedVolumeEntry 9 } 
 | 
						|
 | 
						|
 | 
						|
eqliscsiSharedVolumeFlags OBJECT-TYPE
 | 
						|
    SYNTAX          BITS {
 | 
						|
                        isVvol(0)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This fields defines the common place holder for Volume operational flags. " 
 | 
						|
    DEFVAL          { {} }
 | 
						|
    ::= { eqliscsiSharedVolumeEntry 10 }
 | 
						|
    
 | 
						|
 | 
						|
eqliscsiSharedVolumeSecondaryLunId OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the secondary LUN id for the volume
 | 
						|
                     This is an auto-generated field for internal use only."
 | 
						|
    ::=   { eqliscsiSharedVolumeEntry 11 }
 | 
						|
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
 | 
						|
eqlVmwareVirtualVolumeTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqlVmwareVirtualVolumeEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Table for storing vmWare specific for virtual volume. 
 | 
						|
                     Note all virtual volumes are implemented as shared volumes. This table stores
 | 
						|
                     information that is not used by the PS-Group and is only used by vmware. "
 | 
						|
    ::=    { eqliscsiTarget 84 }
 | 
						|
 | 
						|
 | 
						|
eqlVmwareVirtualVolumeEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqlVmwareVirtualVolumeEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing information used by vmWare for this virtual volume.
 | 
						|
                     Note columns in this table are not used by PS-Group, for the most purpose they 
 | 
						|
                     are opaque for the PS-Group. They only persist information relevant to vmWare"
 | 
						|
    INDEX        { eqliscsiLocalMemberId , eqliscsiSharedVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqlVmwareVirtualVolumeTable 1 }
 | 
						|
 | 
						|
EqlVmwareVirtualVolumeEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
                
 | 
						|
        eqlVmwareVirtualVolumeRowStatus               RowStatus,
 | 
						|
        eqlVmwareVirtualVolumeType                    VirtualVolumeType,   
 | 
						|
        eqlVmWareVirtualVolumeIfSnapshotCreateDate    Counter32
 | 
						|
    }
 | 
						|
 | 
						|
eqlVmwareVirtualVolumeRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."
 | 
						|
    ::=   { eqlVmwareVirtualVolumeEntry 1}
 | 
						|
 | 
						|
eqlVmwareVirtualVolumeType OBJECT-TYPE      
 | 
						|
    SYNTAX          VirtualVolumeType
 | 
						|
    MAX-ACCESS      read-write
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies vmware virtual volume type."     
 | 
						|
       ::=   { eqlVmwareVirtualVolumeEntry 2 }
 | 
						|
 | 
						|
eqlVmWareVirtualVolumeIfSnapshotCreateDate OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter32  
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the time at which this snapshot was created
 | 
						|
                     Time is represented as the time in seconds since 00:00:00 UTC, 1970-01-01.
 | 
						|
                     It is meant to be used by the VASA provider to cleanup all the 
 | 
						|
                     in-progress snapshots that were never completed by VMware" 
 | 
						|
    ::= { eqlVmwareVirtualVolumeEntry 3 }
 | 
						|
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatusTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiSharedVolumeStatusEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage Volume Table.
 | 
						|
                     This table contains a list of volumes in a group and their stats." 
 | 
						|
    ::=    { eqliscsiTarget 85 }   
 | 
						|
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatusEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiSharedVolumeStatusEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing volume stats."
 | 
						|
    AUGMENTS        { eqliscsiSharedVolumeEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiSharedVolumeStatusTable 1}     
 | 
						|
 | 
						|
EqliscsiSharedVolumeStatusEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiSharedVolumeStatusAllocatedSpace        Unsigned32,
 | 
						|
        eqliscsiSharedVolumeStatusSharedSpace           Unsigned32,        
 | 
						|
        eqliscsiSharedVolumeStatusOperStatus            INTEGER        
 | 
						|
      }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatusAllocatedSpace  OBJECT-TYPE
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    UNITS           "MB"
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "The value of this object represents the actual materialized pages for this volume."
 | 
						|
    ::=   {eqliscsiSharedVolumeStatusEntry 1 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatusSharedSpace  OBJECT-TYPE
 | 
						|
   SYNTAX          Unsigned32
 | 
						|
   MAX-ACCESS      read-only
 | 
						|
   STATUS          current      
 | 
						|
   DESCRIPTION     "This field represents the number of pages the volume shares with other shared volumes."
 | 
						|
    ::=   {eqliscsiSharedVolumeStatusEntry 2 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatusOperStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER     {
 | 
						|
                        available(1),
 | 
						|
                        not-available(2),                        
 | 
						|
                        not-available-due-to-members-offline(3),
 | 
						|
                        not-available-due-to-lost-cached-blocks(4),
 | 
						|
                        not-available-due-to-thin-max-growth-met(5),
 | 
						|
                        not-available-due-to-nospace-for-auto-grow(7),
 | 
						|
                        not-available-due-to-missing-pages(8),                        
 | 
						|
                        not-available-due-to-internal-error(9)
 | 
						|
    }         
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the current operational status of the shared volume."
 | 
						|
    ::= {   eqliscsiSharedVolumeStatusEntry 3 }
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiDynVVolTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiDynVVolEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic VVol Table.
 | 
						|
                     This table is a Dyn table used by clients only to CREATE or DELETE VVol 
 | 
						|
                     entries. The information contained in this table corresponds to fields present 
 | 
						|
                     in the eqliscsiVolumeTable and the eqlVVolTable. A successful CREATE on this
 | 
						|
                     table will result in CREATION of rows in eqliscsiVolumeTable and eqlVVolTable.
 | 
						|
                     A successful DELETE on this table will result in DELETION of rows in 
 | 
						|
                     eqliscsiVolumeTable and eqlVVolTable.
 | 
						|
					 TimeoutCreate:60"
 | 
						|
 | 
						|
    ::=    { eqliscsiTarget 86 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiDynVVolEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiDynVVolEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing the Dyn VVol Information."
 | 
						|
    INDEX	{ eqliscsiLocalMemberId , eqliscsiSharedVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqliscsiDynVVolTable 1}     
 | 
						|
 | 
						|
EqliscsiDynVVolEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiDynVVolRowStatus                         RowStatus,
 | 
						|
        eqliscsiDynVVolName                              UTFString,
 | 
						|
        eqliscsiDynVVolSize                              Integer32,
 | 
						|
        eqliscsiDynVVolContainer                         EQL2PartRowPointerStr,
 | 
						|
        eqliscsiDynVVolDesc                              UTFString,
 | 
						|
        eqliscsiDynVVolCreatedAs                         VirtualVolumeCreatedAs,
 | 
						|
        eqliscsiDynVVolIfSnapshotOrFastCloneMyParentVVol EQL2PartRowPointerStr,
 | 
						|
        eqliscsiDynVVolType                              VirtualVolumeType,
 | 
						|
        eqliscsiDynVVolCreateIsDerived                   TruthValue,
 | 
						|
        eqliscsiDynVVolCreateDerivedType                 INTEGER,
 | 
						|
        eqliscsiDynVVolCreateDerivedFromParent           EQL2PartRowPointerStr,
 | 
						|
        eqliscsiDynVVolIfSnapshotMyStatus                VirtualVolumeSnapshotStatus,
 | 
						|
        eqliscsiDynVVolPsvid                             OCTET STRING
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiDynVVolRowStatus OBJECT-TYPE
 | 
						|
    SYNTAX          RowStatus
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field indicates whether the VVol row is ACTIVE or not."
 | 
						|
    ::= { eqliscsiDynVVolEntry 1}
 | 
						|
 | 
						|
eqliscsiDynVVolName OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (1..64))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a user friendly name for a VVol.
 | 
						|
                     The name must be unique within a group.
 | 
						|
                     The name must not contain spaces or special characters.
 | 
						|
                     The name can be up to 64 characters in length. There is no default."
 | 
						|
    ::=  {  eqliscsiDynVVolEntry 2 }  
 | 
						|
 | 
						|
eqliscsiDynVVolSize OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the VVol size in MB. There is no default.
 | 
						|
                     Note: VVol size is round to a multiple of 15MB."
 | 
						|
    ::=   { eqliscsiDynVVolEntry 3 }   
 | 
						|
 | 
						|
 | 
						|
eqliscsiDynVVolContainer OBJECT-TYPE
 | 
						|
    SYNTAX          EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field contains the index of the container to place this VVol in."    
 | 
						|
    ::=   { eqliscsiDynVVolEntry 4 }
 | 
						|
 | 
						|
eqliscsiDynVVolDesc OBJECT-TYPE
 | 
						|
    SYNTAX          UTFString (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a descriptive string that provides details about the volume.
 | 
						|
                     The description can be up to 128 characters. There is no default value."  
 | 
						|
    ::=   { eqliscsiDynVVolEntry 5 }
 | 
						|
 | 
						|
eqliscsiDynVVolCreatedAs OBJECT-TYPE      
 | 
						|
    SYNTAX          VirtualVolumeCreatedAs
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies how this virtual volume was created."     
 | 
						|
       ::=   { eqliscsiDynVVolEntry 6 } 
 | 
						|
 | 
						|
eqliscsiDynVVolIfSnapshotOrFastCloneMyParentVVol OBJECT-TYPE 
 | 
						|
    SYNTAX          EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "Only applicable if vvol was created as a snapshot or a fast-clone. 
 | 
						|
                     Gives information about the parent VVol."
 | 
						|
    ::=  { eqliscsiDynVVolEntry 7}
 | 
						|
 | 
						|
eqliscsiDynVVolType OBJECT-TYPE
 | 
						|
    SYNTAX          VirtualVolumeType 
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field stores the type of the VVol."
 | 
						|
    ::=   { eqliscsiDynVVolEntry 8 }
 | 
						|
 | 
						|
eqliscsiDynVVolCreateIsDerived   OBJECT-TYPE
 | 
						|
   SYNTAX            TruthValue
 | 
						|
   MAX-ACCESS        read-create
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "Truth value only applicable on VVol create request, used to 
 | 
						|
                      indicate if the new VVol to create is a derived VVol."                      
 | 
						|
   ::=   { eqliscsiDynVVolEntry 9 }
 | 
						|
 | 
						|
eqliscsiDynVVolCreateDerivedType   OBJECT-TYPE
 | 
						|
   SYNTAX              INTEGER  {                     
 | 
						|
                              snapshot(2),
 | 
						|
                              fast-clone(3),
 | 
						|
                              clone(4)
 | 
						|
                     }
 | 
						|
   MAX-ACCESS        read-create
 | 
						|
   STATUS            current
 | 
						|
   DESCRIPTION       "Only applicable when creating new vvols and if Dervied is true, indicates 
 | 
						|
                      how the new VVol should be derived from the parent VVol"
 | 
						|
   ::=   { eqliscsiDynVVolEntry 10 }
 | 
						|
 | 
						|
eqliscsiDynVVolCreateDerivedFromParent OBJECT-TYPE      
 | 
						|
    SYNTAX          EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "Only applicable when creating new vvols and if isDerived is true, 
 | 
						|
                     contains the index of the volume to derive from."
 | 
						|
    ::=  { eqliscsiDynVVolEntry 11 }
 | 
						|
 | 
						|
eqliscsiDynVVolIfSnapshotMyStatus OBJECT-TYPE
 | 
						|
    SYNTAX          VirtualVolumeSnapshotStatus
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the snapshot status if the virtual volume, is a snapshot of another volume."
 | 
						|
       ::=   { eqliscsiDynVVolEntry 12 }
 | 
						|
 | 
						|
eqliscsiDynVVolPsvid OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This is read-only field, it stores the unique universal identifier for this
 | 
						|
                     Virtual volume. " 
 | 
						|
    ::=  { eqliscsiDynVVolEntry 13 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqlDynamicSharedVolumeCopyTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqlDynamicSharedVolumeCopyEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic shared volume rollback table.
 | 
						|
                     This table is a dynamic table used by clients rollback a shared volume to a snapshot shared volume."
 | 
						|
 | 
						|
    ::=    { eqliscsiTarget 87 }     
 | 
						|
 | 
						|
eqlDynamicSharedVolumeCopyEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqlDynamicSharedVolumeCopyEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing the dynamic VVol Information."
 | 
						|
    INDEX	{ eqliscsiLocalMemberId , eqliscsiSharedVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqlDynamicSharedVolumeCopyTable 1 }
 | 
						|
 | 
						|
EqlDynamicSharedVolumeCopyEntry ::= 
 | 
						|
    SEQUENCE {
 | 
						|
        eqlDynamicSharedVolumeCopyRowStatus          RowStatus,
 | 
						|
        eqlDynamicSharedVolumeCopyDestSharedVolume   EQL2PartRowPointerStr,
 | 
						|
        eqlDynamicSharedVolumeCopySourceSharedVolume EQL2PartRowPointerStr
 | 
						|
    }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeCopyRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."
 | 
						|
    ::=   { eqlDynamicSharedVolumeCopyEntry 1 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeCopyDestSharedVolume OBJECT-TYPE      
 | 
						|
    SYNTAX          EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field identifes the destination of the rollback."                    
 | 
						|
    ::=  { eqlDynamicSharedVolumeCopyEntry 2 }
 | 
						|
 | 
						|
 | 
						|
eqlDynamicSharedVolumeCopySourceSharedVolume OBJECT-TYPE      
 | 
						|
    SYNTAX          EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field identifes the destination of the rollback."
 | 
						|
    ::=  { eqlDynamicSharedVolumeCopyEntry 3 }
 | 
						|
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqlDynamicSharedVolumeBindUnbindTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqlDynamicSharedVolumeBindUnbindEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic shared volume bind unbind table
 | 
						|
                     This write-only table is a dynamic table used by clients to bind a shared volume to a host."
 | 
						|
 | 
						|
    ::=    { eqliscsiTarget 88 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeBindUnbindEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqlDynamicSharedVolumeBindUnbindEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing the dynamic VVol Information."
 | 
						|
    INDEX	{ eqliscsiLocalMemberId , eqliscsiSharedVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqlDynamicSharedVolumeBindUnbindTable 1 }
 | 
						|
 | 
						|
EqlDynamicSharedVolumeBindUnbindEntry ::= 
 | 
						|
    SEQUENCE {
 | 
						|
        eqlDynamicSharedVolumeBindUnbindRowStatus         RowStatus,
 | 
						|
        eqlDynamicSharedVolumeBindUnbindOper              INTEGER,
 | 
						|
        eqlDynamicSharedVolumeBindUnbindAccessGroupIndex  Unsigned32,
 | 
						|
        eqlDynamicSharedVolumeBindUnbindOperAugment       INTEGER
 | 
						|
    }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeBindUnbindRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."
 | 
						|
    ::=   { eqlDynamicSharedVolumeBindUnbindEntry 1 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeBindUnbindOper OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER    {
 | 
						|
                        bind (1),
 | 
						|
                        unbind (2)                        
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field identifes the bind/unbind operation"                    
 | 
						|
    ::=  { eqlDynamicSharedVolumeBindUnbindEntry 2 }
 | 
						|
 | 
						|
 | 
						|
eqlDynamicSharedVolumeBindUnbindAccessGroupIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          Unsigned32
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field identifes the host/access group to 
 | 
						|
                     bind this shared volume to."
 | 
						|
    ::=  { eqlDynamicSharedVolumeBindUnbindEntry 3 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeBindUnbindOperAugment OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER    {
 | 
						|
                        update (0),
 | 
						|
                        updateAccess (1),
 | 
						|
                        doNotUpdateAccess(2)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field identifes the bind/unbind augemented operation. 0,1 are used to make sure the
 | 
						|
                     ACL fields are updated/created. Option 2 make it so that we DO NOT cleanup ACL's. This would
 | 
						|
                     be used for member down status"
 | 
						|
    ::=  { eqlDynamicSharedVolumeBindUnbindEntry 4 }
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiSharedVolumeMetadataTable OBJECT-TYPE
 | 
						|
	SYNTAX			SEQUENCE OF EqliscsiSharedVolumeMetadataEntry
 | 
						|
	MAX-ACCESS 		not-accessible
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"EqualLogic-Persistent Table for storing metadata of shared volumes."
 | 
						|
	::= 	{ eqliscsiTarget 89 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeMetadataEntry OBJECT-TYPE
 | 
						|
	SYNTAX 			EqliscsiSharedVolumeMetadataEntry
 | 
						|
	MAX-ACCESS 		not-accessible
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"Each entry represents a key-value pair combination for a shared volume. Each shared volume 
 | 
						|
                                 may have several key-value properties in which case a shared volume will be represented 
 | 
						|
                                 by more than one entry where each entry is a specific key-value pair (metadata)."
 | 
						|
	INDEX 			{eqliscsiLocalMemberId, eqliscsiSharedVolumeIndex, eqliscsiSharedVolumeMetadataIndex}
 | 
						|
 | 
						|
	::= {eqliscsiSharedVolumeMetadataTable 1}
 | 
						|
 | 
						|
EqliscsiSharedVolumeMetadataEntry ::=
 | 
						|
	SEQUENCE {
 | 
						|
		eqliscsiSharedVolumeMetadataRowStatus 		RowStatus,
 | 
						|
		eqliscsiSharedVolumeMetadataIndex 		Unsigned32,		
 | 
						|
		eqliscsiSharedVolumeMetadataKey 		UTFString,
 | 
						|
		eqliscsiSharedVolumeMetadataValue 		UTFString
 | 
						|
	} 
 | 
						|
 | 
						|
eqliscsiSharedVolumeMetadataRowStatus OBJECT-TYPE
 | 
						|
	SYNTAX 			RowStatus
 | 
						|
	MAX-ACCESS 		read-create
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"This field is used to indicate the status of the shared volume metadata entry."
 | 
						|
	::= {eqliscsiSharedVolumeMetadataEntry 1}
 | 
						|
 | 
						|
eqliscsiSharedVolumeMetadataIndex OBJECT-TYPE
 | 
						|
	SYNTAX 			Unsigned32
 | 
						|
	MAX-ACCESS 		not-accessible
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"This field specifies a unique index for identifying the shared volume metadata."
 | 
						|
	::= {eqliscsiSharedVolumeMetadataEntry 2}
 | 
						|
 | 
						|
eqliscsiSharedVolumeMetadataKey OBJECT-TYPE
 | 
						|
	SYNTAX 			UTFString(SIZE(1..65))
 | 
						|
	MAX-ACCESS 		read-create
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"Key represents the metadata field name. 
 | 
						|
                                 The maximum supported length of this field 
 | 
						|
                                 including the NULL character is 65."
 | 
						|
	::= {eqliscsiSharedVolumeMetadataEntry 3}
 | 
						|
 | 
						|
eqliscsiSharedVolumeMetadataValue OBJECT-TYPE
 | 
						|
	SYNTAX 			UTFString(SIZE(1..255))
 | 
						|
	MAX-ACCESS 		read-create
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"This field represents the value of the metadata field.
 | 
						|
                                The maximum supported length of this field
 | 
						|
                                including the NULL character is 255."
 | 
						|
	::= {eqliscsiSharedVolumeMetadataEntry 4}
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqlPreppedSnapshotVVolTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqlPreppedSnapshotVVolEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Persistent Table for storing virtual volumes that 
 | 
						|
                     represent prepped snapshots.
 | 
						|
                     Note this is a transient state, VMWare creates snapshots in 2 steps 
 | 
						|
                     1) prepareToSnapshotVirtualVolume
 | 
						|
                     2) snapshotVirtualVolume                     
 | 
						|
                     This table stages all the VVOLS all the Virtual volumes that were created 
 | 
						|
                     as a result of the 1st step. Once the 2nd step is executed these 
 | 
						|
                     virtual volumes will transition into being real Shared Volumes on 
 | 
						|
                     the equallogic PS-Group. 
 | 
						|
                     Entries in this table use the same index as the shared volume table, because 
 | 
						|
                     VMware requires that PS-Group generate the volume identifier in step 1 
 | 
						|
                     and it will use this identifier for all forthcoming operations to 
 | 
						|
                     this volume.
 | 
						|
                     Entries in this table will have a corressponding entry in the 
 | 
						|
                     VmwareVirtualTable this table keeps track of the VVOL Type 
 | 
						|
                     (config, data, swap)"
 | 
						|
                    
 | 
						|
    ::=    { eqliscsiTarget 90 }     
 | 
						|
 | 
						|
 | 
						|
eqlPreppedSnapshotVVolEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqlPreppedSnapshotVVolEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing status for shared volume the values 
 | 
						|
                     in this table are user configurable."
 | 
						|
    INDEX        { eqliscsiLocalMemberId , eqliscsiSharedVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqlPreppedSnapshotVVolTable 1}     
 | 
						|
 | 
						|
EqlPreppedSnapshotVVolEntry ::= 
 | 
						|
    SEQUENCE {                 
 | 
						|
        eqlPreppedSnapshotVVolRowStatus              RowStatus,
 | 
						|
        eqlPreppedSnapshotVVolPsvid                  OCTET STRING,
 | 
						|
        eqlPreppedSnapshotVVolName                   UTFString,
 | 
						|
        eqlPreppedSnapshotVVolSize                   Integer32,        
 | 
						|
        eqlPreppedSnapshotVVolMyParentVVol           EQL2PartRowPointerStr,
 | 
						|
        eqlPreppedSnapshotVVolBucket                 EQL2PartRowPointerStr,
 | 
						|
        eqlPreppedSnapshotVVolDescription            UTFString
 | 
						|
    }
 | 
						|
 | 
						|
eqlPreppedSnapshotVVolRowStatus  OBJECT-TYPE
 | 
						|
    SYNTAX          RowStatus
 | 
						|
    MAX-ACCESS      read-only
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."  
 | 
						|
    ::=   { eqlPreppedSnapshotVVolEntry 1}
 | 
						|
 | 
						|
 | 
						|
eqlPreppedSnapshotVVolPsvid OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))     
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is a unique universal identifier for this
 | 
						|
                     shared volume. This field is mostly for internal use only." 
 | 
						|
    ::=  { eqlPreppedSnapshotVVolEntry 2 }
 | 
						|
 | 
						|
eqlPreppedSnapshotVVolName OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (1..64))    
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY
 | 
						|
                     This field specifies a user friendly name for the shared volume.
 | 
						|
                     The name must be unique within a group.
 | 
						|
                     The name must not contain spaces or special characters.
 | 
						|
                     The name can be up to 64 characters in length. There is no default."
 | 
						|
    ::=  {  eqlPreppedSnapshotVVolEntry 3 }
 | 
						|
 | 
						|
eqlPreppedSnapshotVVolSize OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32
 | 
						|
    UNITS           "MB"  
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the volume size in MB. There is no default.
 | 
						|
                     Note: Volume size is round to a multiple of 15MB. All shared volumes 
 | 
						|
                     are thin provisioned so this value represents the advertized size 
 | 
						|
                     of the volume"
 | 
						|
    ::=   { eqlPreppedSnapshotVVolEntry 4 }
 | 
						|
 | 
						|
 | 
						|
eqlPreppedSnapshotVVolMyParentVVol OBJECT-TYPE      
 | 
						|
    SYNTAX          EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS      read-only      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EQL-SECONDARY-KEY 
 | 
						|
                     This field is only applicable to shared volumes that are created
 | 
						|
                     as snapshots. If snapshot shared volume, this field identifies 
 | 
						|
                     the parent." 
 | 
						|
    ::=  { eqlPreppedSnapshotVVolEntry 5 }
 | 
						|
 | 
						|
eqlPreppedSnapshotVVolBucket OBJECT-TYPE
 | 
						|
    SYNTAX          EQL2PartRowPointerStr
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "This field contains the index of the bucket that contains this prepped snapshot."    
 | 
						|
    ::=   { eqlPreppedSnapshotVVolEntry 6 }
 | 
						|
  
 | 
						|
eqlPreppedSnapshotVVolDescription OBJECT-TYPE      
 | 
						|
    SYNTAX          UTFString (SIZE (0..128))    
 | 
						|
    MAX-ACCESS      read-only    
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies a descriptive string that provides details about the volume.
 | 
						|
                     The description can be up to 128 characters. There is no default value."  
 | 
						|
    ::=  {  eqlPreppedSnapshotVVolEntry 7 }
 | 
						|
    
 | 
						|
--*******************************************************************************
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqlDynamicSharedVolumeDiffEntry
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic shared volume difference table
 | 
						|
                     This write-only table is a dynamic table used by clients to perform a difference 
 | 
						|
                     between 2 volumes"
 | 
						|
 | 
						|
    ::=    { eqliscsiTarget 91 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqlDynamicSharedVolumeDiffEntry      
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "An entry (row) containing the dynamic row. The Index will be the VVol"
 | 
						|
    INDEX   { eqliscsiLocalMemberId , eqliscsiSharedVolumeIndex }
 | 
						|
 | 
						|
    ::=   { eqlDynamicSharedVolumeDiffTable 1 }
 | 
						|
 | 
						|
EqlDynamicSharedVolumeDiffEntry ::= 
 | 
						|
    SEQUENCE {
 | 
						|
        eqlDynamicSharedVolumeDiffRowStatus             RowStatus,
 | 
						|
        eqlDynamicSharedVolumeDiffBaseIndex             EQL2PartRowPointerStr,        
 | 
						|
        eqlDynamicSharedVolumeDiffAdmin                 INTEGER,
 | 
						|
        eqlDynamicSharedVolumeDiffStartSegmentOffset    Counter64,
 | 
						|
        eqlDynamicSharedVolumeDiffSegmentsLength        Counter64, 
 | 
						|
        eqlDynamicSharedVolumeDiffChunkSize             Unsigned32
 | 
						|
    }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this entry."
 | 
						|
    ::=   { eqlDynamicSharedVolumeDiffEntry 1 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffBaseIndex OBJECT-TYPE      
 | 
						|
    SYNTAX          EQL2PartRowPointerStr    
 | 
						|
    MAX-ACCESS      read-create
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the base shared volume index associated with the shared volume."
 | 
						|
    ::=   { eqlDynamicSharedVolumeDiffEntry 2}
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffAdmin OBJECT-TYPE      
 | 
						|
    SYNTAX          INTEGER    {
 | 
						|
                        unSharedBitMap  (1),
 | 
						|
                        allocatedBitMap (2),
 | 
						|
                        unsharedChunks  (3)
 | 
						|
    }
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field identifes the type of diff ooperation"                    
 | 
						|
    ::=  { eqlDynamicSharedVolumeDiffEntry 3 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffStartSegmentOffset    OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64 
 | 
						|
    MAX-ACCESS    read-create
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "This value represents the starting segment for the diff operation"
 | 
						|
    ::= { eqlDynamicSharedVolumeDiffEntry 4 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffSegmentsLength    OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64 
 | 
						|
    MAX-ACCESS    read-create
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "This value represents the segments size being requested. "
 | 
						|
    ::= { eqlDynamicSharedVolumeDiffEntry 5 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffChunkSize    OBJECT-TYPE
 | 
						|
    SYNTAX        Unsigned32 
 | 
						|
    MAX-ACCESS    read-create
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "This value represents the size of the Chunk entry for the bit map or other calculation"
 | 
						|
    ::= { eqlDynamicSharedVolumeDiffEntry 6 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiVolumeCompressionConfigurationTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqliscsiVolumeCompressionConfigurationEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Persistent
 | 
						|
      This table defines volume specific compression paramters.
 | 
						|
      "
 | 
						|
::= { eqliscsiTarget 92 }
 | 
						|
 | 
						|
eqliscsiVolumeCompressionConfigurationEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqliscsiVolumeCompressionConfigurationEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
      "An entry in the volume compression configuration table."
 | 
						|
    INDEX           { eqliscsiLocalMemberId , eqliscsiVolumeIndex }
 | 
						|
::= { eqliscsiVolumeCompressionConfigurationTable 1 }
 | 
						|
 | 
						|
EqliscsiVolumeCompressionConfigurationEntry ::= SEQUENCE {
 | 
						|
   eqliscsiVolumeCompressionConfigurationRowStatus               RowStatus,
 | 
						|
   eqliscsiVolumeCompressionConfigurationPolicy                  INTEGER,
 | 
						|
   eqliscsiVolumeCompressionConfigurationSnapDelay               Integer32
 | 
						|
}
 | 
						|
 | 
						|
eqliscsiVolumeCompressionConfigurationRowStatus OBJECT-TYPE      
 | 
						|
    SYNTAX          RowStatus    
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field is used indicate the status of this table entry."  
 | 
						|
    ::= { eqliscsiVolumeCompressionConfigurationEntry 1 }  
 | 
						|
 | 
						|
eqliscsiVolumeCompressionConfigurationPolicy OBJECT-TYPE
 | 
						|
   SYNTAX INTEGER {
 | 
						|
            automatic(0),  -- Allow system to determine which snapshots to compress
 | 
						|
            always(1), -- Immediately mark all snapshots created by this policy as compressible
 | 
						|
            user-defined(2), -- Provide a user-defined amount of time to wait before marking for compression
 | 
						|
            never(3) -- Never mark snapshots created by this schedule as compressible
 | 
						|
   }
 | 
						|
    MAX-ACCESS        read-create
 | 
						|
    STATUS            current      
 | 
						|
    DESCRIPTION       "Specify how this volume's snapshots should be compressed."
 | 
						|
    DEFVAL            { automatic }
 | 
						|
    ::=   { eqliscsiVolumeCompressionConfigurationEntry 2 }
 | 
						|
 | 
						|
eqliscsiVolumeCompressionConfigurationSnapDelay  OBJECT-TYPE      
 | 
						|
    SYNTAX          Integer32 
 | 
						|
    UNITS           "minutes"
 | 
						|
    MAX-ACCESS      read-create      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     
 | 
						|
          " 
 | 
						|
            The value of this object represents how long to wait prior
 | 
						|
            to marking a snapshot as eligible for compression.
 | 
						|
            Current default is 24 hours.  
 | 
						|
            Only used when eqliscsiVolumeCompressionConfigurationPolicy
 | 
						|
            is set to user-defined.
 | 
						|
          "
 | 
						|
    DEFVAL          { 1440 }
 | 
						|
    ::=  {  eqliscsiVolumeCompressionConfigurationEntry 3 }
 | 
						|
 | 
						|
 | 
						|
 | 
						|
--*******************************************************************************
 | 
						|
eqlDynamicSharedVolumeDiffChunkTable OBJECT-TYPE
 | 
						|
    SYNTAX        SEQUENCE OF EqlDynamicSharedVolumeDiffChunkEntry
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
     "EqualLogic-Dynamic. This table exposes the vvol as number of chunks."
 | 
						|
::= { eqliscsiTarget 93 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffChunkEntry OBJECT-TYPE
 | 
						|
    SYNTAX        EqlDynamicSharedVolumeDiffChunkEntry 
 | 
						|
    MAX-ACCESS    not-accessible
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION   "Information related to each chunk."
 | 
						|
    INDEX        { eqliscsiLocalMemberId , eqliscsiSharedVolumeIndex, eqlDynamicSharedVolumeDiffChunkIndex }
 | 
						|
::= { eqlDynamicSharedVolumeDiffChunkTable 1 }
 | 
						|
 | 
						|
EqlDynamicSharedVolumeDiffChunkEntry ::= SEQUENCE {
 | 
						|
   eqlDynamicSharedVolumeDiffChunkIndex         Unsigned32,
 | 
						|
   eqlDynamicSharedVolumeDiffChunkSegmentSize   Unsigned32,
 | 
						|
   eqlDynamicSharedVolumeDiffNumChunkSegments   Unsigned32,
 | 
						|
   eqlDynamicSharedVolumeDiffChunkModified      OCTET STRING
 | 
						|
}
 | 
						|
eqlDynamicSharedVolumeDiffChunkIndex    OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32 
 | 
						|
   MAX-ACCESS    not-accessible
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents index of the chunk. "
 | 
						|
::= { eqlDynamicSharedVolumeDiffChunkEntry 1 }
 | 
						|
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffChunkSegmentSize    OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32 
 | 
						|
   UNITS         "KB"
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents the size of a segment. This is passed in to the row create of the eqlDynamicSharedVolumeDiffChunkTable"
 | 
						|
::= { eqlDynamicSharedVolumeDiffChunkEntry 2 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffNumChunkSegments    OBJECT-TYPE
 | 
						|
   SYNTAX        Unsigned32 
 | 
						|
   UNITS         "segments"
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents the size of the chunk expressed as number of segments. "
 | 
						|
::= { eqlDynamicSharedVolumeDiffChunkEntry 3 }
 | 
						|
 | 
						|
eqlDynamicSharedVolumeDiffChunkModified    OBJECT-TYPE
 | 
						|
   SYNTAX        OCTET STRING (SIZE(1024))
 | 
						|
   MAX-ACCESS    read-only
 | 
						|
   STATUS        current
 | 
						|
   DESCRIPTION
 | 
						|
      "This value represents a bit mask of modified segments in the given chunk."
 | 
						|
::= { eqlDynamicSharedVolumeDiffChunkEntry 4 }
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiVolumeMetadataTable OBJECT-TYPE
 | 
						|
	SYNTAX			SEQUENCE OF EqliscsiVolumeMetadataEntry
 | 
						|
	MAX-ACCESS 		not-accessible
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"EqualLogic-Persistent Table for storing metadata of volumes."
 | 
						|
	::= 	{ eqliscsiTarget 94 }
 | 
						|
 | 
						|
eqliscsiVolumeMetadataEntry OBJECT-TYPE
 | 
						|
	SYNTAX 			EqliscsiVolumeMetadataEntry
 | 
						|
	MAX-ACCESS 		not-accessible
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"Each entry represents a key-value pair combination for a volume. Each volume may have 
 | 
						|
                         several key-value properties in which case a volume will be represented by more than 
 | 
						|
                         one entry where each entry is a specific key-value pair (metadata)."
 | 
						|
	INDEX 			{eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiVolumeMetadataIndex}
 | 
						|
 | 
						|
	::= {eqliscsiVolumeMetadataTable 1}
 | 
						|
 | 
						|
EqliscsiVolumeMetadataEntry ::=
 | 
						|
	SEQUENCE {
 | 
						|
		eqliscsiVolumeMetadataRowStatus 	RowStatus,
 | 
						|
		eqliscsiVolumeMetadataIndex 		Unsigned32,		
 | 
						|
		eqliscsiVolumeMetadataKey 		    UTFString,
 | 
						|
		eqliscsiVolumeMetadataValue 		UTFString
 | 
						|
	} 
 | 
						|
 | 
						|
eqliscsiVolumeMetadataRowStatus OBJECT-TYPE
 | 
						|
	SYNTAX 			RowStatus
 | 
						|
	MAX-ACCESS 		read-create
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"This field is used to indicate the status of the volume metadata entry."
 | 
						|
	::= {eqliscsiVolumeMetadataEntry 1}
 | 
						|
 | 
						|
eqliscsiVolumeMetadataIndex OBJECT-TYPE
 | 
						|
	SYNTAX 			Unsigned32
 | 
						|
	MAX-ACCESS 		not-accessible
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"This field specifies a unique index for identifying the volume metadata."
 | 
						|
	::= {eqliscsiVolumeMetadataEntry 2}
 | 
						|
 | 
						|
eqliscsiVolumeMetadataKey OBJECT-TYPE
 | 
						|
	SYNTAX 			UTFString(SIZE(1..65))
 | 
						|
	MAX-ACCESS 		read-create
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"EQL-SECONDARY-KEY
 | 
						|
				 Key represents the metadata field name. 
 | 
						|
                                 The maximum supported length of this field 
 | 
						|
                                 including the NULL character is 65."
 | 
						|
	::= {eqliscsiVolumeMetadataEntry 3}
 | 
						|
 | 
						|
eqliscsiVolumeMetadataValue OBJECT-TYPE
 | 
						|
	SYNTAX 			UTFString(SIZE(1..255))
 | 
						|
	MAX-ACCESS 		read-create
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"This field represents the value of the metadata field.
 | 
						|
                                The maximum supported length of this field
 | 
						|
                                including the NULL character is 255."
 | 
						|
	::= {eqliscsiVolumeMetadataEntry 4}
 | 
						|
 | 
						|
--******************************************************************
 | 
						|
 | 
						|
eqliscsiSnapshotMetadataTable OBJECT-TYPE
 | 
						|
	SYNTAX			SEQUENCE OF EqliscsiSnapshotMetadataEntry
 | 
						|
	MAX-ACCESS 		not-accessible
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"EqualLogic-Persistent Table for storing metadata of snapshots."
 | 
						|
	::= 	{ eqliscsiTarget 95 }
 | 
						|
 | 
						|
eqliscsiSnapshotMetadataEntry OBJECT-TYPE
 | 
						|
	SYNTAX 			EqliscsiSnapshotMetadataEntry
 | 
						|
	MAX-ACCESS 		not-accessible
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"Each entry represents a key-value pair combination for a snapshot. Each snapshot may have 
 | 
						|
                         several key-value properties in which case a snapshot will be represented by more than one 
 | 
						|
                         entry where each entry is a specific key-value pair (metadata)."
 | 
						|
	INDEX 			{eqliscsiLocalMemberId, eqliscsiVolumeIndex, eqliscsiSnapshotIndex, eqliscsiSnapshotMetadataIndex}
 | 
						|
 | 
						|
	::= {eqliscsiSnapshotMetadataTable 1}
 | 
						|
 | 
						|
EqliscsiSnapshotMetadataEntry ::=
 | 
						|
	SEQUENCE {
 | 
						|
		eqliscsiSnapshotMetadataRowStatus 	RowStatus,
 | 
						|
		eqliscsiSnapshotMetadataIndex 		Unsigned32,		
 | 
						|
		eqliscsiSnapshotMetadataKey 		UTFString,
 | 
						|
		eqliscsiSnapshotMetadataValue 		UTFString
 | 
						|
	} 
 | 
						|
 | 
						|
eqliscsiSnapshotMetadataRowStatus OBJECT-TYPE
 | 
						|
	SYNTAX 			RowStatus
 | 
						|
	MAX-ACCESS 		read-create
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"This field is used to indicate the status of the snapshot metadata entry."
 | 
						|
	::= {eqliscsiSnapshotMetadataEntry 1}
 | 
						|
 | 
						|
eqliscsiSnapshotMetadataIndex OBJECT-TYPE
 | 
						|
	SYNTAX 			Unsigned32
 | 
						|
	MAX-ACCESS 		not-accessible
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"This field specifies a unique index for identifying the snapshot metadata."
 | 
						|
	::= {eqliscsiSnapshotMetadataEntry 2}
 | 
						|
 | 
						|
eqliscsiSnapshotMetadataKey OBJECT-TYPE
 | 
						|
	SYNTAX 			UTFString(SIZE(1..65))
 | 
						|
	MAX-ACCESS 		read-create
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"EQL-SECONDARY-KEY
 | 
						|
				 Key represents the metadata field name. 
 | 
						|
                                 The maximum supported length of this field 
 | 
						|
                                 including the NULL character is 65."
 | 
						|
	::= {eqliscsiSnapshotMetadataEntry 3}
 | 
						|
 | 
						|
eqliscsiSnapshotMetadataValue OBJECT-TYPE
 | 
						|
	SYNTAX 			UTFString(SIZE(1..255))
 | 
						|
	MAX-ACCESS 		read-create
 | 
						|
	STATUS 			current
 | 
						|
	DESCRIPTION 		"This field represents the value of the metadata field.
 | 
						|
                                The maximum supported length of this field
 | 
						|
                                including the NULL character is 255."
 | 
						|
	::= {eqliscsiSnapshotMetadataEntry 4}
 | 
						|
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiSyncReplAfoTiebreakerTable OBJECT-TYPE
 | 
						|
    SYNTAX  SEQUENCE OF EqliscsiSyncReplAfoTiebreakerEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "Equalogic-member local AFO tiebreaker"
 | 
						|
    ::= { eqliscsiTarget  96 }
 | 
						|
 | 
						|
eqliscsiSyncReplAfoTiebreakerEntry OBJECT-TYPE
 | 
						|
    SYNTAX          EqliscsiSyncReplAfoTiebreakerEntry
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An member local entry (row) containing a volume's AFO tiebreaker for synchronous replication
 | 
						|
                     The first 4 indexes identify the volume with the lowest psvid, and 
 | 
						|
                     the second 4 indexes identify the volume with the highest psvid."
 | 
						|
    INDEX           { eqliscsiVolumeLowPsvId0 , eqliscsiVolumeLowPsvId1, eqliscsiVolumeLowPsvId2 , eqliscsiVolumeLowPsvId3,
 | 
						|
                      eqliscsiVolumeHighPsvId0 , eqliscsiVolumeHighPsvId1, eqliscsiVolumeHighPsvId2 , eqliscsiVolumeHighPsvId3 }
 | 
						|
    ::= { eqliscsiSyncReplAfoTiebreakerTable 1 }
 | 
						|
 | 
						|
EqliscsiSyncReplAfoTiebreakerEntry ::=
 | 
						|
    SEQUENCE {
 | 
						|
        eqliscsiSyncReplAfoTiebreakerSeqNum              Counter64,
 | 
						|
        eqliscsiSyncReplAfoTiebreaker                    OCTET STRING,
 | 
						|
        eqliscsiSyncReplAfoTiebreakerGrpLeadUuid         OCTET STRING
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiSyncReplAfoTiebreakerSeqNum  OBJECT-TYPE      
 | 
						|
    SYNTAX          Counter64    
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This field specifies the sequence number for the record"
 | 
						|
    ::=  {eqliscsiSyncReplAfoTiebreakerEntry 1 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSyncReplAfoTiebreaker  OBJECT-TYPE      
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This value represents the UUID of the Tiebreaker"
 | 
						|
    ::=  {eqliscsiSyncReplAfoTiebreakerEntry 2 }
 | 
						|
 | 
						|
 | 
						|
eqliscsiSyncReplAfoTiebreakerGrpLeadUuid  OBJECT-TYPE
 | 
						|
    SYNTAX          OCTET STRING (SIZE (16))    
 | 
						|
    MAX-ACCESS      not-accessible      
 | 
						|
    STATUS          current      
 | 
						|
    DESCRIPTION     "This value represents the UUID of the Group lead that wrote this record"
 | 
						|
    ::= { eqliscsiSyncReplAfoTiebreakerEntry 3 }
 | 
						|
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatisticsTable OBJECT-TYPE      
 | 
						|
    SYNTAX          SEQUENCE OF EqliscsiSharedVolumeStatisticsEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "EqualLogic-Dynamic Storage SharedVolume Table.
 | 
						|
                     This table contains a list of volumes in a group and their statistics." 
 | 
						|
    ::=    { eqliscsiTarget 97 }     
 | 
						|
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatisticsEntry OBJECT-TYPE      
 | 
						|
    SYNTAX          EqliscsiSharedVolumeStatisticsEntry      
 | 
						|
    MAX-ACCESS      not-accessible
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION     "An entry (row) containing volume statistics."
 | 
						|
    AUGMENTS        { eqliscsiSharedVolumeEntry }
 | 
						|
 | 
						|
    ::=   { eqliscsiSharedVolumeStatisticsTable 1}     
 | 
						|
 | 
						|
EqliscsiSharedVolumeStatisticsEntry ::= 
 | 
						|
    SEQUENCE { 
 | 
						|
        eqliscsiSharedVolumeStatsCmdPdus            Counter32,
 | 
						|
        eqliscsiSharedVolumeStatsRspPdus            Counter32,
 | 
						|
        eqliscsiSharedVolumeStatsTxData             Counter64,
 | 
						|
        eqliscsiSharedVolumeStatsRxData             Counter64,
 | 
						|
        eqliscsiSharedVolumeStatsNoOfSessions       Unsigned32,
 | 
						|
        eqliscsiSharedVolumeStatsReadLatency        Counter64,
 | 
						|
        eqliscsiSharedVolumeStatsWriteLatency       Counter64,
 | 
						|
        eqliscsiSharedVolumeStatsReadOpCount        Counter64,
 | 
						|
        eqliscsiSharedVolumeStatsWriteOpCount       Counter64,
 | 
						|
        eqliscsiSharedVolumeStatsReadAvgLatency        Gauge32,
 | 
						|
        eqliscsiSharedVolumeStatsWriteAvgLatency       Gauge32,
 | 
						|
        eqliscsiSharedVolumeStatsHCIscsiReadWriteCmdsReceived  Counter64,
 | 
						|
        eqliscsiSharedVolumeStatsHCIscsiTotalQD                Counter64,
 | 
						|
        eqliscsiSharedVolumeStatsMisAlignedIO       Counter64
 | 
						|
    }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsCmdPdus OBJECT-TYPE
 | 
						|
    SYNTAX        Counter32
 | 
						|
    UNITS         "PDUs"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of Command PDUs transferred to this volume."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 1 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsRspPdus OBJECT-TYPE
 | 
						|
    SYNTAX        Counter32
 | 
						|
    UNITS         "PDUs"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of Response PDUs transferred to this volume."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 2 }
 | 
						|
    
 | 
						|
eqliscsiSharedVolumeStatsTxData OBJECT-TYPE
 | 
						|
    SYNTAX         Counter64
 | 
						|
    UNITS         "octets"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of data octets that were transmitted by
 | 
						|
        the local iSCSI node."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 3 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsRxData OBJECT-TYPE
 | 
						|
    SYNTAX         Counter64
 | 
						|
    UNITS         "octets"
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS          current
 | 
						|
    DESCRIPTION
 | 
						|
        "The count of data octets that were received by
 | 
						|
        the local iSCSI node."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 4 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsNoOfSessions OBJECT-TYPE
 | 
						|
    SYNTAX        Unsigned32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "No of sessions that were established and closed so far to this volume. 
 | 
						|
        "
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 5 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsReadLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The accumulative latency in milli seconds for read operations on this volume."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 6 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsWriteLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The accumulative latency in milli seconds for write operations on this volume."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 7 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsReadOpCount OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of read operations on this volume."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 8 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsWriteOpCount OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of write operations on this volume."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 9 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsReadAvgLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Gauge32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The average latency in milli seconds for read operations on this volume."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 10 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsWriteAvgLatency OBJECT-TYPE
 | 
						|
    SYNTAX        Gauge32
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The average latency in milli seconds for write operations on this volume."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 11 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsHCIscsiReadWriteCmdsReceived  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "The number of iscsi read/write commands received for operations on this volume. 
 | 
						|
        This object is a 64-bit version of eqliscsiSharedVolumeStatsIscsiReadWriteCmdsReceived."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 13 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsHCIscsiTotalQD  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "A 64-bit counter that is incremented by the current number of outstanding iSCSI IO
 | 
						|
        operations each time an iSCSI IO is received by the target.  The iSCSI IO operations include
 | 
						|
        both reads and writes.  This counter when divided by the total number of iSCSI IO operations
 | 
						|
        provides the average queue depth.
 | 
						|
        This object is a 64 bit version of eqliscsiSharedVolumeStatsIscsiReadWriteCmdsCompleted."
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 14 }
 | 
						|
 | 
						|
eqliscsiSharedVolumeStatsMisAlignedIO  OBJECT-TYPE
 | 
						|
    SYNTAX        Counter64
 | 
						|
    MAX-ACCESS    read-only
 | 
						|
    STATUS        current
 | 
						|
    DESCRIPTION
 | 
						|
        "A 64-bit counter that is incremented by the number of mis-aligned I/O operations performed on a volume
 | 
						|
        TODO - beef this up!!!!!" 
 | 
						|
::= { eqliscsiSharedVolumeStatisticsEntry 15 }
 | 
						|
 | 
						|
---*************************************************************  
 | 
						|
 | 
						|
END
 |