2549 lines
		
	
	
		
			92 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
			
		
		
	
	
			2549 lines
		
	
	
		
			92 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
    
 | 
						|
--
 | 
						|
-- Copyright (c) 2002 by EqualLogic, Inc.
 | 
						|
-- 
 | 
						|
-- All rights reserved.  This software may not be copied, disclosed,
 | 
						|
-- transferred, or used except in accordance with a license granted
 | 
						|
-- by EqualLogic, Inc.  This software embodies proprietary information
 | 
						|
-- and trade secrets of EqualLogic, Inc.
 | 
						|
--
 | 
						|
 | 
						|
   SCSI-MIB DEFINITIONS ::= BEGIN 
 | 
						|
    
 | 
						|
   IMPORTS 
 | 
						|
     MODULE-IDENTITY, OBJECT-TYPE, NOTIFICATION-TYPE, 
 | 
						|
     Integer32, Unsigned32, Counter32,  
 | 
						|
     Counter64, Gauge32, 
 | 
						|
     mib-2                                        FROM SNMPv2-SMI 
 | 
						|
     TEXTUAL-CONVENTION, TimeStamp, TruthValue, 
 | 
						|
     RowStatus, RowPointer, AutonomousType        FROM SNMPv2-TC 
 | 
						|
     MODULE-COMPLIANCE, OBJECT-GROUP              FROM SNMPv2-CONF 
 | 
						|
     SnmpAdminString                     FROM SNMP-FRAMEWORK-MIB; 
 | 
						|
           
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiModule MODULE-IDENTITY 
 | 
						|
     LAST-UPDATED "200202250000Z"         -- 25 February 2002 
 | 
						|
     ORGANIZATION "IETF" 
 | 
						|
     CONTACT-INFO " 
 | 
						|
          Michele Hallak-Stamler 
 | 
						|
 
 | 
						|
          Sanrad Intelligent Network 
 | 
						|
          32 Habarzel Street 
 | 
						|
          Tel Aviv, Israel 
 | 
						|
      
 | 
						|
          Phone: +972 3 7674809 
 | 
						|
          E-mail: michele@sanrad.com 
 | 
						|
    
 | 
						|
    
 | 
						|
          Yaron Lederman 
 | 
						|
          Siliquent Technologies Ltd. 
 | 
						|
          33 Bezalel Street  
 | 
						|
          Ramat Gan, Israel  
 | 
						|
          
 | 
						|
          Phone: +972 3 7552320 
 | 
						|
          E-mail: yaronl@siliquent.com 
 | 
						|
    
 | 
						|
          Mark Bakke 
 | 
						|
          Postal: Cisco Systems, Inc 
 | 
						|
          6450 Wedgwood Road, Suite 130 
 | 
						|
          Maple Grove, MN 
 | 
						|
          USA 55311 
 | 
						|
    
 | 
						|
          Phone: +1 763-398-1000 
 | 
						|
          Fax: +1 763-398-1001 
 | 
						|
          E-mail: mbakke@cisco.com 
 | 
						|
    
 | 
						|
          Marjorie Krueger 
 | 
						|
          Postal: Hewlett-Packard 
 | 
						|
          Networked Storage Architecture 
 | 
						|
          Networked Storage Solutions Org. 
 | 
						|
          8000 Foothills Blvd. 
 | 
						|
          Roseville, CA 95747 
 | 
						|
    
 | 
						|
          Phone: +1 916-785-2656 
 | 
						|
          Phone: +1 916-785-0391 
 | 
						|
          E-mail: marjorie_krueger@hp.com 
 | 
						|
    
 | 
						|
          Keith McCloghrie 
 | 
						|
          Cisco Systems, Inc. 
 | 
						|
          Postal: 170 West Tasman Drive 
 | 
						|
          San Jose, CA USA 95134 
 | 
						|
    
 | 
						|
          Phone: +1 408 526-5260 
 | 
						|
          E-mail: kzm@cisco.com 
 | 
						|
    
 | 
						|
          " 
 | 
						|
     DESCRIPTION   
 | 
						|
          "The SCSI MIB" 
 | 
						|
           
 | 
						|
   -- Revision History 
 | 
						|
    
 | 
						|
     REVISION     "200202250000Z"            
 | 
						|
     DESCRIPTION  " Initial version published as RFC nnnn." 
 | 
						|
 
 | 
						|
     ::= { mib-2 999}   -- must be changed in the future 
 | 
						|
    
 | 
						|
       
 | 
						|
   ---------------------- Textual Conventions ------------------------- 
 | 
						|
   ScsiLUNOrZero  ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This Textual Convention represents either a SCSI Logical 
 | 
						|
          Unit Number (LUN) or a zero-length string.  Objects defined 
 | 
						|
          with this syntax must specify the meaning of the zero-length 
 | 
						|
          string.  The format of a LUN is: 
 | 
						|
          - a zero-length octet string or  
 | 
						|
          - a string of two octets if the underlying transport protocol 
 | 
						|
          is SBP-3 or SPI-4 using data group transfers or 
 | 
						|
          - a string of eight octets for all other cases." 
 | 
						|
     SYNTAX OCTET STRING (SIZE (0 | 2 | 8)) 
 | 
						|
    
 | 
						|
   ScsiIndexValue   ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " An arbitrary integer value, greater than zero, for use as a 
 | 
						|
          unique index value." 
 | 
						|
     SYNTAX    Unsigned32(1..4294967295) 
 | 
						|
      
 | 
						|
   ScsiPortIndexValueOrZero ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This textual convention is an extension of the 
 | 
						|
          ScsiIndexValue convention.  The latter defines a greater than 
 | 
						|
          zero value used to identify an index.  This extension permits 
 | 
						|
          the additional value of zero and is applicable only to 
 | 
						|
          indices of SCSI port.  Usage of the 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 index was unknown, or 
 | 
						|
          when none or all indices need to be referenced." 
 | 
						|
     SYNTAX    Unsigned32(0..4294967295) 
 | 
						|
    
 | 
						|
   ScsiIndexValueOrZero ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This textual convention is an extension of the 
 | 
						|
          ScsiIndexValue convention.  The latter defines a greater than 
 | 
						|
          zero value used to identify an index.  This extension permits 
 | 
						|
          the additional value of zero. Usage of the 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 index was 
 | 
						|
          unknown, or when none or all indices need to be referenced." 
 | 
						|
     SYNTAX    Unsigned32(0..4294967295) 
 | 
						|
    
 | 
						|
   ScsiIdentifier ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS    current 
 | 
						|
 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This Textual Convention represents a generic SCSI device or 
 | 
						|
          port identifier. 
 | 
						|
          The format depends on the transport used: 
 | 
						|
          - SPI: only bits:0-3 for a port identifier (LSB is 0 and MSB 
 | 
						|
          is 3). Other bits must be zero.  
 | 
						|
          - SPI: identifier of a device is a zero-length octet string. 
 | 
						|
          - FCP: 3 bytes for a port identifier 
 | 
						|
          - FCP: identifier of a device is a zero-length octet string. 
 | 
						|
          - SRP: 16 bytes for a port identifier. 
 | 
						|
          - SRP: it is a zero-length octet string for a device 
 | 
						|
          identifier. 
 | 
						|
          - iSCSI: 256 bytes for a device identifier. 
 | 
						|
          - iSCSI: 258 bytes for a target port identifier. 
 | 
						|
          - iSCSI: 262 bytes for an initiator port identifier. 
 | 
						|
          - SBP: it is a zero-length octet string for a device 
 | 
						|
          identifier. 
 | 
						|
          - SBP: 2 bytes for an initiator port identifier. 
 | 
						|
          - SBP: 11 bytes for a target port identifier. " 
 | 
						|
     SYNTAX OCTET STRING (SIZE (0 | 1 | 2 | 3| 11 | 16 | 256| 258|262)) 
 | 
						|
    
 | 
						|
   ScsiName ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS    current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This Textual Convention represents a generic SCSI device or 
 | 
						|
          port name. 
 | 
						|
          The format depends on the transport used: 
 | 
						|
          - SPI: it is a zero-length octet string for a device or port 
 | 
						|
          name. 
 | 
						|
          - FCP: 8 bytes for a port name. 
 | 
						|
          - FCP: it is a zero-length octet string for a device name. 
 | 
						|
          - SRP: 16 bytes for a port name. 
 | 
						|
          - SRP: it is a zero-length octet string for a device name. 
 | 
						|
          - iSCSI: 256 bytes for a device name. 
 | 
						|
          - iSCSI: 258 bytes for a target port name. 
 | 
						|
          - iSCSI: 262 bytes for an initiator port name. 
 | 
						|
          - SBP: it is a zero-length octet string for a device name. 
 | 
						|
          - SBP: 8 bytes for an initiator port name. 
 | 
						|
          - SBP: 11 bytes for a target port name. " 
 | 
						|
     SYNTAX OCTET STRING (SIZE (0 | 8 | 11 |16 | 256 | 258| 262)) 
 | 
						|
    
 | 
						|
   ScsiNameIdOrZero ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This Textual Convention represents either the SCSI name of 
 | 
						|
          a logical unit or a zero-length string.  Objects defined with 
 | 
						|
          this syntax must specify the meaning of the zero-length 
 | 
						|
          string.  The format of the name of a LU is: 
 | 
						|
          - a zero-length octet string or  
 | 
						|
          - a string of eight octets." 
 | 
						|
   SYNTAX OCTET STRING (SIZE (0 | 8)) 
 | 
						|
    
 | 
						|
   ScsiDeviceOrPort ::= TEXTUAL-CONVENTION 
 | 
						|
 
 | 
						|
     STATUS    current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This type specifies whether a particular configuration is 
 | 
						|
          applicable to a port or to a device." 
 | 
						|
     SYNTAX    INTEGER   { 
 | 
						|
          device(1), 
 | 
						|
          port(2), 
 | 
						|
          other(3) 
 | 
						|
     } 
 | 
						|
    
 | 
						|
   ScsiIdCodeSet ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS    current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This Textual Convention specifies the code set in use with 
 | 
						|
          this identifier. 
 | 
						|
          The format is the same as contained in the identifier's 
 | 
						|
          Identification Descriptor within the Logical Unit's Device 
 | 
						|
          Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), Revision 20, 18 
 | 
						|
          July 2001 Chapter 8: section 8.4.4, page 210 Vital Product 
 | 
						|
          Data Parameters [16]" 
 | 
						|
     SYNTAX    Unsigned32(0..15) 
 | 
						|
    
 | 
						|
   ScsiIdAssociation ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS    current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This Textual Convention specifies what the identifier is 
 | 
						|
          associated with (e.g, with the addressed physical/logical 
 | 
						|
          device or with a particular port).   
 | 
						|
          The format is the same as contained in the identifier's 
 | 
						|
          Identification Descriptor within the Logical Unit's Device 
 | 
						|
          Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), Revision 20, 18 
 | 
						|
          July 2001 - Chapter 8: section 8.4.4, page 210 Vital Product 
 | 
						|
          Data Parameters [16]" 
 | 
						|
     SYNTAX    Unsigned32(0..3) 
 | 
						|
    
 | 
						|
   ScsiIdType ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS    current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This Textual Convention specifies the type of the 
 | 
						|
          identifier.  
 | 
						|
          The format is the same as contained in the identifier's 
 | 
						|
          Identification Descriptor within the Logical Unit's Device 
 | 
						|
          Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), Revision 20, 
 | 
						|
          Chapter 8: section 8.4.4, page 210 Vital Product Data 
 | 
						|
          Parameters  [16]" 
 | 
						|
     SYNTAX    Unsigned32(0..15) 
 | 
						|
    
 | 
						|
 
 | 
						|
   ScsiIdValue ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS    current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This Textual Convention represents an identifier. The 
 | 
						|
          objects of type ScsiIdCodeSet, ScsIdAssociation, ScsiIdType, 
 | 
						|
          define together the format. 
 | 
						|
          The format is the same as contained in the identifier's 
 | 
						|
          Identification Descriptor within the Logical Unit's Device 
 | 
						|
          Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), Revision 20, 18 
 | 
						|
          July 2001 - Chapter 8: section 8.4.4, page 210 Vital Product 
 | 
						|
          Data Parameters [16]" 
 | 
						|
     SYNTAX    OCTET STRING (SIZE (0..255)) 
 | 
						|
    
 | 
						|
    
 | 
						|
   HrSWInstalledIndexOrZero ::= TEXTUAL-CONVENTION 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "The index value for a software module's row in the Host 
 | 
						|
          Resources MIB's hrSWInstalledTable.  A zero value indicates 
 | 
						|
          that no row in the hrSWInstalledTable is applicable." 
 | 
						|
     REFERENCE 
 | 
						|
          "hrSWInstalledTable is defined in the Host Resources MIB, RFC 
 | 
						|
          2790." 
 | 
						|
     SYNTAX   Integer32 (0..2147483647) 
 | 
						|
    
 | 
						|
   ----------------------- Structure of the MIB ---------------------- 
 | 
						|
    
 | 
						|
   scsiObjects           OBJECT IDENTIFIER ::= { scsiModule 1 } 
 | 
						|
   scsiNotifications     OBJECT IDENTIFIER ::= { scsiModule 2 } 
 | 
						|
   scsiConformance       OBJECT IDENTIFIER ::= { scsiModule 3 } 
 | 
						|
    
 | 
						|
   scsiTransportTypes    OBJECT IDENTIFIER ::= { scsiObjects 1 } 
 | 
						|
   scsiGeneral           OBJECT IDENTIFIER ::= { scsiObjects 2 } 
 | 
						|
   scsiInitiator         OBJECT IDENTIFIER ::= { scsiObjects 3 } 
 | 
						|
   scsiTarget            OBJECT IDENTIFIER ::= { scsiObjects 4 } 
 | 
						|
   scsiLogicalUnit       OBJECT IDENTIFIER ::= { scsiObjects 5 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   -- Transport Types 
 | 
						|
   scsiTranportOther     OBJECT IDENTIFIER ::= { scsiTransportTypes 1 } 
 | 
						|
   scsiTranportSPI       OBJECT IDENTIFIER ::= { scsiTransportTypes 2 } 
 | 
						|
   scsiTransportFCP      OBJECT IDENTIFIER ::= { scsiTransportTypes 3 } 
 | 
						|
   scsiTransportSRP      OBJECT IDENTIFIER ::= { scsiTransportTypes 4 } 
 | 
						|
   scsiTransportISCSI    OBJECT IDENTIFIER ::= { scsiTransportTypes 5 } 
 | 
						|
   scsiTransportSBP      OBJECT IDENTIFIER ::= { scsiTransportTypes 6 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   ----------------------- Instance Table ----------------------------- 
 | 
						|
   scsiInstanceTable OBJECT-TYPE 
 | 
						|
     SYNTAX         SEQUENCE OF ScsiInstanceEntry 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "A list of SCSI instances present on the system. 
 | 
						|
          The SCSI Instance is the top-level entity, to which 
 | 
						|
          everything else belongs. An SNMP agent could represent more 
 | 
						|
          than one instance if it represents either a stack of devices, 
 | 
						|
          or virtual partitions of a larger device, or a host running 
 | 
						|
          multiple SCSI implementations from different vendors." 
 | 
						|
     ::= { scsiGeneral 1 } 
 | 
						|
    
 | 
						|
   scsiInstanceEntry OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiInstanceEntry 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) containing management information applicable 
 | 
						|
          to a particular SCSI instance." 
 | 
						|
     INDEX { scsiInstIndex } 
 | 
						|
     ::= { scsiInstanceTable 1 } 
 | 
						|
    
 | 
						|
   ScsiInstanceEntry::= SEQUENCE { 
 | 
						|
          scsiInstIndex                 ScsiIndexValue, 
 | 
						|
          scsiInstAlias                 SnmpAdminString, 
 | 
						|
          scsiInstSoftwareIndex         HrSWInstalledIndexOrZero, 
 | 
						|
          scsiInstVendorVersion         SnmpAdminString, 
 | 
						|
          scsiInstScsiNotificationsEnable    TruthValue 
 | 
						|
   } 
 | 
						|
    
 | 
						|
   scsiInstIndex OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents an arbitrary integer used to uniquely 
 | 
						|
          identify a particular SCSI instance." 
 | 
						|
     ::= { scsiInstanceEntry 1 } 
 | 
						|
    
 | 
						|
   scsiInstAlias OBJECT-TYPE 
 | 
						|
     SYNTAX         SnmpAdminString (SIZE(0..79)) 
 | 
						|
     MAX-ACCESS     read-write 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents an administrative string, configured 
 | 
						|
          by the administrator. It can be a zero-length string." 
 | 
						|
     ::= { scsiInstanceEntry 2 } 
 | 
						|
    
 | 
						|
   scsiInstSoftwareIndex    OBJECT-TYPE 
 | 
						|
     SYNTAX         HrSWInstalledIndexOrZero 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "If this management instance corresponds to an installed 
 | 
						|
          software module, then this object's value is the value of the 
 | 
						|
 
 | 
						|
          hrSWInstalledIndex of that module.  If there is no 
 | 
						|
          correspondence to an installed software module (or no module 
 | 
						|
          which has a hrSWInstalledIndex value), then the value of this 
 | 
						|
          object is zero." 
 | 
						|
     REFERENCE 
 | 
						|
          "hrSWInstalledIndex is defined in the Host Resources MIB, RFC 
 | 
						|
          2790." 
 | 
						|
     ::= { scsiInstanceEntry 3 } 
 | 
						|
    
 | 
						|
   scsiInstVendorVersion OBJECT-TYPE 
 | 
						|
     SYNTAX         SnmpAdminString(SIZE(0..79)) 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents a text string set by the manufacturer 
 | 
						|
          describing the version of this instance.  The format of this 
 | 
						|
          string is determined solely by the manufacturer, and is for 
 | 
						|
          informational purposes only.  It is unrelated to the SCSI 
 | 
						|
          specification version numbers." 
 | 
						|
     ::= { scsiInstanceEntry 4 } 
 | 
						|
    
 | 
						|
   scsiInstScsiNotificationsEnable OBJECT-TYPE 
 | 
						|
     SYNTAX         TruthValue 
 | 
						|
     MAX-ACCESS     read-write 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object allows to enable/disable sending all the 
 | 
						|
          notifications defined in this MIB." 
 | 
						|
     DEFVAL { true } 
 | 
						|
     ::= { scsiInstanceEntry 5 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiDeviceTable  OBJECT-TYPE 
 | 
						|
     SYNTAX           SEQUENCE OF ScsiDeviceEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "A list of SCSI Devices present on the system." 
 | 
						|
     ::= { scsiGeneral 2 } 
 | 
						|
    
 | 
						|
   scsiDeviceEntry OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiDeviceEntry 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) containing management information applicable 
 | 
						|
          to a particular SCSI Device included in this SCSI manageable 
 | 
						|
          instance." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex } 
 | 
						|
     ::= { scsiDeviceTable 1 } 
 | 
						|
    
 | 
						|
   ScsiDeviceEntry::= SEQUENCE { 
 | 
						|
 
 | 
						|
          scsiDeviceIndex          ScsiIndexValue, 
 | 
						|
          scsiDeviceAlias          SnmpAdminString, 
 | 
						|
          scsiDeviceRole           BITS, 
 | 
						|
          scsiDevicePortNumber     Unsigned32, 
 | 
						|
          scsiDeviceResets         Counter32 
 | 
						|
   } 
 | 
						|
    
 | 
						|
   scsiDeviceIndex OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object is an arbitrary integer used to uniquely 
 | 
						|
          identify a particular device within a particular SCSI 
 | 
						|
          instance." 
 | 
						|
     ::= { scsiDeviceEntry 1 } 
 | 
						|
    
 | 
						|
   scsiDeviceAlias OBJECT-TYPE 
 | 
						|
     SYNTAX         SnmpAdminString (SIZE(0..79)) 
 | 
						|
     MAX-ACCESS     read-write 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents is an admistrative name for this 
 | 
						|
          device. If no name is assigned, the value of this object is 
 | 
						|
          the zero-length string." 
 | 
						|
     ::= { scsiDeviceEntry 2 } 
 | 
						|
    
 | 
						|
   scsiDeviceRole OBJECT-TYPE 
 | 
						|
     SYNTAX    BITS { 
 | 
						|
               target(0), 
 | 
						|
               initiator(1) 
 | 
						|
          } 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object determines whether this device is acting as an 
 | 
						|
          initiator device, or as a target device or as both." 
 | 
						|
     ::= { scsiDeviceEntry 3 } 
 | 
						|
    
 | 
						|
   scsiDevicePortNumber OBJECT-TYPE 
 | 
						|
     SYNTAX         Unsigned32 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
       "This object represents the number of ports contained in this 
 | 
						|
       device." 
 | 
						|
     ::= { scsiDeviceEntry 4 } 
 | 
						|
    
 | 
						|
   scsiDeviceResets      OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
 
 | 
						|
          "This object represents the number of times that this device 
 | 
						|
          has reset." 
 | 
						|
     ::= { scsiDeviceEntry 5 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   ----------------------- Port Table ---------------------------------
 | 
						|
   scsiPortTable  OBJECT-TYPE 
 | 
						|
     SYNTAX  SEQUENCE OF ScsiPortEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "A list of SCSI Ports for each SCSI device in each instance." 
 | 
						|
     ::= { scsiGeneral 3 } 
 | 
						|
    
 | 
						|
   scsiPortEntry OBJECT-TYPE 
 | 
						|
     SYNTAX              ScsiPortEntry 
 | 
						|
     MAX-ACCESS          not-accessible 
 | 
						|
     STATUS              current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) containing management information applicable 
 | 
						|
          to a particular SCSI port of a particular SCSI device in a 
 | 
						|
          particular SCSI instance." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiPortIndex } 
 | 
						|
     ::= { scsiPortTable  1 } 
 | 
						|
    
 | 
						|
   ScsiPortEntry ::= SEQUENCE { 
 | 
						|
     scsiPortIndex            ScsiIndexValue, 
 | 
						|
     scsiPortRole             BITS, 
 | 
						|
     scsiPortTrnsptPtr        OCTET STRING, -- was RowPointer, 
 | 
						|
     scsiPortBusyStatuses     Counter32 
 | 
						|
   } 
 | 
						|
    
 | 
						|
   scsiPortIndex OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An arbitrary integer used to uniquely identify a particular 
 | 
						|
          port of a given device within a particular SCSI instance." 
 | 
						|
     ::= { scsiPortEntry 1 } 
 | 
						|
    
 | 
						|
   scsiPortRole OBJECT-TYPE 
 | 
						|
     SYNTAX    BITS { 
 | 
						|
               target(0), 
 | 
						|
               initiator(1) 
 | 
						|
          } 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object indicates whether this port is acting as an 
 | 
						|
          initiator port, or as a target port or as both." 
 | 
						|
     ::= { scsiPortEntry 2 } 
 | 
						|
    
 | 
						|
 
 | 
						|
   scsiPortTrnsptPtr OBJECT-TYPE 
 | 
						|
     SYNTAX         OCTET STRING  (SIZE(1..255))  -- was RowPointer 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
       "This object is a pointer to the corresponding row in the 
 | 
						|
       scsiTrnsptTable" 
 | 
						|
     ::= { scsiPortEntry 3 } 
 | 
						|
    
 | 
						|
   scsiPortBusyStatuses OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the number of port busy status sent 
 | 
						|
          or received by this port. Note: Initiator ports only receive 
 | 
						|
          busy status and target ports only send busy status." 
 | 
						|
     ::= { scsiPortEntry 4 } 
 | 
						|
    
 | 
						|
   scsiTrnsptTable OBJECT-TYPE 
 | 
						|
     SYNTAX           SEQUENCE OF ScsiTrnsptEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table contains a list of transports in use with each 
 | 
						|
          SCSI device." 
 | 
						|
     ::= { scsiGeneral 5 } 
 | 
						|
    
 | 
						|
   scsiTrnsptEntry OBJECT-TYPE 
 | 
						|
     SYNTAX              ScsiTrnsptEntry 
 | 
						|
     MAX-ACCESS          not-accessible 
 | 
						|
     STATUS              current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) containing parameters applicable to a 
 | 
						|
          transport used by a particular device of a particular SCSI 
 | 
						|
          manageable instance." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiTrnsptIndex} 
 | 
						|
     ::= { scsiTrnsptTable 1 } 
 | 
						|
    
 | 
						|
   ScsiTrnsptEntry ::= SEQUENCE { 
 | 
						|
     scsiTrnsptIndex     ScsiIndexValue, 
 | 
						|
     scsiTrnsptType      OCTET STRING, -- was AutonomousType, 
 | 
						|
     scsiTrnsptPointer   OCTET STRING, -- was RowPointer, 
 | 
						|
     scsiTrnsptDevName   ScsiName 
 | 
						|
   } 
 | 
						|
    
 | 
						|
   scsiTrnsptIndex  OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
 
 | 
						|
          "An arbitrary integer used to uniquely identify a particular 
 | 
						|
          transport within a given device within a particular SCSI 
 | 
						|
          instance." 
 | 
						|
     ::= { scsiTrnsptEntry 1 } 
 | 
						|
    
 | 
						|
   scsiTrnsptType   OBJECT-TYPE 
 | 
						|
     SYNTAX         OCTET STRING (SIZE (0..255))  -- was AutonomousType 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the type of transport for this 
 | 
						|
          particular transport." 
 | 
						|
     ::= { scsiTrnsptEntry 2 } 
 | 
						|
    
 | 
						|
   scsiTrnsptPointer     OBJECT-TYPE 
 | 
						|
     SYNTAX         OCTET STRING  (SIZE(1..255))  -- was RowPointer 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents a pointer to a conceptual row in a 
 | 
						|
          'transport' MIB allowing a manager to get useful information 
 | 
						|
          for the transport described by this entry. 
 | 
						|
          For example, if the transport of this device is iSCSI, this 
 | 
						|
          object will point to the iSCSI Instance of the iSCSI MIB. 
 | 
						|
          If there is no MIB for this transport, this object has the 
 | 
						|
          value 0.0." 
 | 
						|
     ::= { scsiTrnsptEntry 3 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiTrnsptDevName     OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiName 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the name of this device in one of 
 | 
						|
          the format(s) appropriate for this type of transport." 
 | 
						|
     ::= { scsiTrnsptEntry 4 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   ----------------------- Initiator Device Table ---------------------
 | 
						|
   scsiIntrDevTable  OBJECT-TYPE 
 | 
						|
     SYNTAX           SEQUENCE OF ScsiIntrDevEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table contains information for each local initiator 
 | 
						|
          device." 
 | 
						|
    ::= { scsiInitiator 1} 
 | 
						|
    
 | 
						|
   scsiIntrDevEntry OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiIntrDevEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) containing information applicable to an 
 | 
						|
          initiator device within a particular SCSI instance." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex } 
 | 
						|
     ::= { scsiIntrDevTable  1 } 
 | 
						|
    
 | 
						|
   ScsiIntrDevEntry ::= SEQUENCE { 
 | 
						|
     scsiIntrDevTgtAccessMode INTEGER, 
 | 
						|
     scsiIntrDevOutResets     Counter32 
 | 
						|
     } 
 | 
						|
    
 | 
						|
   scsiIntrDevTgtAccessMode   OBJECT-TYPE 
 | 
						|
     SYNTAX    INTEGER { 
 | 
						|
               unknown(1), 
 | 
						|
               autoEnable(2), 
 | 
						|
               manualEnable(3) 
 | 
						|
     } 
 | 
						|
     MAX-ACCESS     read-write 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object controls whether a discovered target is 
 | 
						|
          immediately authorized or not: 
 | 
						|
          - autoEnable (2) means that when an initiator discovers a 
 | 
						|
          target, it can use it immediately,  
 | 
						|
          - manualEnable (3) means that the initiator must wait for an 
 | 
						|
          operator to set scsiIntrDscTgtConfigured = true before it is 
 | 
						|
          authorized." 
 | 
						|
     ::= { scsiIntrDevEntry 1 } 
 | 
						|
    
 | 
						|
   scsiIntrDevOutResets  OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the number of resets sent by this 
 | 
						|
          initiator."  
 | 
						|
     ::= { scsiIntrDevEntry 2 } 
 | 
						|
    
 | 
						|
     
 | 
						|
    
 | 
						|
   -- The following section describes managed objects related to  
 | 
						|
   -- initiator ports. 
 | 
						|
   scsiIntrPrtTable OBJECT-TYPE 
 | 
						|
     SYNTAX          SEQUENCE OF ScsiIntrPrtEntry 
 | 
						|
     MAX-ACCESS      not-accessible 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table contains all the initiator ports of local SCSI 
 | 
						|
          Initiator or Target/Initiator devices." 
 | 
						|
     ::= { scsiInitiator 3 } 
 | 
						|
    
 | 
						|
   scsiIntrPrtEntry OBJECT-TYPE 
 | 
						|
     SYNTAX          ScsiIntrPrtEntry 
 | 
						|
 
 | 
						|
     MAX-ACCESS      not-accessible 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) containing information applicable to a 
 | 
						|
          particular initiator port of a particular device within a 
 | 
						|
          SCSI instance. " 
 | 
						|
   INDEX { scsiInstIndex, scsiDeviceIndex, scsiPortIndex } 
 | 
						|
     ::= { scsiIntrPrtTable 1 } 
 | 
						|
    
 | 
						|
   ScsiIntrPrtEntry ::= SEQUENCE { 
 | 
						|
     scsiIntrPrtName               ScsiName, 
 | 
						|
     scsiIntrPrtIdentifier         ScsiIdentifier, 
 | 
						|
     scsiIntrPrtOutCommands        Counter32, 
 | 
						|
     scsiIntrPrtWrittenMegaBytes   Counter32, 
 | 
						|
     scsiIntrPrtReadMegaBytes      Counter32, 
 | 
						|
     scsiIntrPrtHSOutCommands      Counter64 
 | 
						|
   } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiIntrPrtName OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiName 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the name of the port assigned for 
 | 
						|
          use by the SCSI protocol. The format will depend of the type 
 | 
						|
          of transport this port is using." 
 | 
						|
     ::= { scsiIntrPrtEntry 1 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiIntrPrtIdentifier OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIdentifier 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the identifier of the port in one of 
 | 
						|
          the format(s) appropriate for the type of transport in use." 
 | 
						|
     ::= { scsiIntrPrtEntry 2 } 
 | 
						|
    
 | 
						|
   scsiIntrPrtOutCommands     OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the number of commands sent by this 
 | 
						|
          initiator." 
 | 
						|
     ::= { scsiIntrPrtEntry 3 } 
 | 
						|
    
 | 
						|
   scsiIntrPrtWrittenMegaBytes          OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the amount of data in Megabytes sent 
 | 
						|
          by this initiator." 
 | 
						|
     ::= { scsiIntrPrtEntry 4 } 
 | 
						|
    
 | 
						|
 
 | 
						|
   scsiIntrPrtReadMegaBytes   OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the amount of data in Megabytes 
 | 
						|
          received by this initiator." 
 | 
						|
     ::= { scsiIntrPrtEntry 5 } 
 | 
						|
    
 | 
						|
   scsiIntrPrtHSOutCommands   OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter64 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the number of commands sent by this 
 | 
						|
          initiator device. This object provides support for systems 
 | 
						|
          which can quickly generate lots of commands because they run 
 | 
						|
          at high speed." 
 | 
						|
     ::= { scsiIntrPrtEntry 6 } 
 | 
						|
    
 | 
						|
   scsiRemoteTarget OBJECT IDENTIFIER ::= { scsiInitiator 4 } 
 | 
						|
    
 | 
						|
   -- Targets discovered or authorized to attach each of the initiator 
 | 
						|
   -- ports of each initiator device of each instance.  
 | 
						|
   scsiDscTgtTable OBJECT-TYPE 
 | 
						|
     SYNTAX         SEQUENCE OF ScsiDscTgtEntry 
 | 
						|
     MAX-ACCESS      not-accessible 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table includes all the remote (not in the local system) 
 | 
						|
          target ports that are authorized to attach to each local 
 | 
						|
          initiator port of this SCSI instance." 
 | 
						|
     ::= { scsiRemoteTarget 1 } 
 | 
						|
    
 | 
						|
   scsiDscTgtEntry OBJECT-TYPE 
 | 
						|
     SYNTAX              ScsiDscTgtEntry 
 | 
						|
     MAX-ACCESS          not-accessible 
 | 
						|
     STATUS              current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) represents an authorization for one or all 
 | 
						|
          local initiator ports of a local device (scsiDeviceIndex) 
 | 
						|
          within a local SCSI instance (scsiInstIndex), to attach to a 
 | 
						|
          remote target port or device (scsiDscTgtIndex).  The 
 | 
						|
 
 | 
						|
          authorization is either for all local ports if 
 | 
						|
          scsiDscTgtIntrPortIndex is zero, or otherwise only for the 
 | 
						|
          specific port identified by scsiDscTgtIntrPortIndex. 
 | 
						|
          Note that when an entry in this table is deleted, then any 
 | 
						|
          corresponding entries in the scsiDscLunsTable should be 
 | 
						|
          deleted as well." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiDscTgtIntrPortIndex, 
 | 
						|
     scsiDscTgtIndex } 
 | 
						|
   ::= { scsiDscTgtTable 1 } 
 | 
						|
    
 | 
						|
   ScsiDscTgtEntry ::= SEQUENCE { 
 | 
						|
     scsiDscTgtIntrPortIndex  ScsiPortIndexValueOrZero, 
 | 
						|
     scsiDscTgtIndex          ScsiIndexValue, 
 | 
						|
     scsiDscTgtDevOrPort      ScsiDeviceOrPort, 
 | 
						|
     scsiDscTgtName           ScsiName, 
 | 
						|
     scsiDscTgtConfigured     TruthValue, 
 | 
						|
     scsiDscTgtDiscovered     TruthValue, 
 | 
						|
     scsiDscTgtInCommands     Counter32, 
 | 
						|
     scsiDscTgtWrittenMegaBytes    Counter32, 
 | 
						|
     scsiDscTgtReadMegaBytes  Counter32, 
 | 
						|
     scsiDscTgtHSInCommands   Counter64, 
 | 
						|
     scsiDscTgtLastCreation   TimeStamp, 
 | 
						|
     scsiDscTgtRowStatus      RowStatus 
 | 
						|
   } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiDscTgtIntrPortIndex    OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiPortIndexValueOrZero 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object relates to a particular local device within a 
 | 
						|
          particular SCSI instance and specifies: 
 | 
						|
          - the index of the local scsi initiator port, 
 | 
						|
          - or zero, if this entry refers to the local device and 
 | 
						|
          therefore refers to all the local initiator ports." 
 | 
						|
     ::= { scsiDscTgtEntry 1 } 
 | 
						|
    
 | 
						|
   scsiDscTgtIndex OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object is an arbitrary integer used to uniquely 
 | 
						|
          identify a particular authorized target amongst those 
 | 
						|
          authorized for one or more ports (of a particular device 
 | 
						|
          within a particular SCSI instance) to attach to."  
 | 
						|
     ::= { scsiDscTgtEntry 2 } 
 | 
						|
    
 | 
						|
   scsiDscTgtDevOrPort OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiDeviceOrPort 
 | 
						|
     MAX-ACCESS     read-create 
 | 
						|
     STATUS         current 
 | 
						|
 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object specifies whether the authorization represented 
 | 
						|
          by this row applies to a remote target port or remote target 
 | 
						|
          device." 
 | 
						|
     ::= { scsiDscTgtEntry 3 } 
 | 
						|
    
 | 
						|
   scsiDscTgtName OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiName 
 | 
						|
     MAX-ACCESS     read-create 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the name of this 
 | 
						|
          authorized/discovered target device or port." 
 | 
						|
     ::= { scsiDscTgtEntry 4 } 
 | 
						|
    
 | 
						|
   scsiDscTgtConfigured OBJECT-TYPE 
 | 
						|
     SYNTAX         TruthValue 
 | 
						|
     MAX-ACCESS     read-create 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object means: 
 | 
						|
          -true(1): this entry has been configured by an administrator 
 | 
						|
          -false(2): this entry has been added from other source. 
 | 
						|
          An administrator can modify this value from false to true." 
 | 
						|
     DEFVAL { true } 
 | 
						|
     ::= { scsiDscTgtEntry 5 } 
 | 
						|
    
 | 
						|
   scsiDscTgtDiscovered OBJECT-TYPE 
 | 
						|
     SYNTAX         TruthValue 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object means: 
 | 
						|
          -true(1): this entry has been discovered by the SCSI instance. 
 | 
						|
          -false(2): this entry has been added from other source. 
 | 
						|
          This entry is read-only because an administrator cannot 
 | 
						|
          change it. 
 | 
						|
          Note that it is an implementation decision to determine how 
 | 
						|
          long to retain a row with configured=false, as and when the 
 | 
						|
          target is no longer visible/accessible to the local 
 | 
						|
          initiator." 
 | 
						|
     ::= { scsiDscTgtEntry 6 } 
 | 
						|
    
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiDscTgtInCommands  OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the number of commands received by 
 | 
						|
          this target port or device." 
 | 
						|
 
 | 
						|
     ::= { scsiDscTgtEntry 7 } 
 | 
						|
    
 | 
						|
   scsiDscTgtWrittenMegaBytes OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the amount of data in Megabytes 
 | 
						|
          written by this target port or device." 
 | 
						|
     ::= { scsiDscTgtEntry 8 } 
 | 
						|
    
 | 
						|
   scsiDscTgtReadMegaBytes    OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the amount of data in Megabytes read 
 | 
						|
          by this target port or device." 
 | 
						|
     ::= { scsiDscTgtEntry 9 } 
 | 
						|
    
 | 
						|
   scsiDscTgtHSInCommands OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter64 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the number of commands received by 
 | 
						|
          this target port or device. This object provides support for 
 | 
						|
          systems which can quickly generate lots of commands because 
 | 
						|
          they run at high speed." 
 | 
						|
     ::= { scsiDscTgtEntry 10 } 
 | 
						|
    
 | 
						|
   scsiDscTgtLastCreation OBJECT-TYPE 
 | 
						|
     SYNTAX         TimeStamp 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the value of sysUpTime when this row 
 | 
						|
          was created." 
 | 
						|
     ::= { scsiDscTgtEntry 11 } 
 | 
						|
      
 | 
						|
    
 | 
						|
   scsiDscTgtRowStatus OBJECT-TYPE 
 | 
						|
     SYNTAX         RowStatus 
 | 
						|
     MAX-ACCESS     read-create 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object allows to configure dynamically a new entry in 
 | 
						|
          this table via SNMP or eventually delete it. 
 | 
						|
 
 | 
						|
          An administrator is not allowed to delete an entry for which 
 | 
						|
          the value of the object scsiIntrDscTgtDiscovered is equal to 
 | 
						|
          true.  
 | 
						|
          Note that when an entry in this table is deleted, then any 
 | 
						|
          corresponding entries in the scsiDscLunsTable must also be 
 | 
						|
          automatically deleted. " 
 | 
						|
     ::= { scsiDscTgtEntry 12 } 
 | 
						|
    
 | 
						|
   scsiDscLunTable OBJECT-TYPE 
 | 
						|
     SYNTAX           SEQUENCE OF ScsiDscLunEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table includes all the remote (not in the local system) 
 | 
						|
          logical unit numbers (LUNS) discovered via each local 
 | 
						|
          initiator port of each local device within a particular SCSI 
 | 
						|
          instance." 
 | 
						|
     ::= { scsiRemoteTarget 2 } 
 | 
						|
    
 | 
						|
   scsiDscLunEntry OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiDscLunEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) represents a discovered LUN at a particular 
 | 
						|
          SCSI target device (scsiDscTgtIndex), where the LUN was 
 | 
						|
          discovered by a particular local initiator device within a 
 | 
						|
          particular SCSI instance, possibly via a particular local 
 | 
						|
          initiator port. 
 | 
						|
          Note that when an entry in the scsiDscTgtTable is deleted, 
 | 
						|
          then any corresponding entries in this table is automatically 
 | 
						|
          deleted." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiDscTgtIntrPortIndex,   
 | 
						|
     scsiDscTgtIndex, scsiDscLunIndex } 
 | 
						|
     ::= { scsiDscLunTable 1 } 
 | 
						|
    
 | 
						|
   ScsiDscLunEntry ::= SEQUENCE { 
 | 
						|
     scsiDscLunIndex     ScsiIndexValue, 
 | 
						|
     scsiDscLunLun       ScsiLUNOrZero   
 | 
						|
   } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiDscLunIndex OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object is an arbitrary integer used to uniquely 
 | 
						|
          identify a particular LUN discovered by a particular scsi 
 | 
						|
          initiator port or a particular SCSI initiator device within a 
 | 
						|
          particular SCSI instance. Entries in the scsiDscLunIdTable 
 | 
						|
 
 | 
						|
          are associated with a LUN by having the value of this object 
 | 
						|
          in their INDEX." 
 | 
						|
     ::= { scsiDscLunEntry 1 } 
 | 
						|
    
 | 
						|
   scsiDscLunLun    OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiLUNOrZero 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object contains the Logical Unit Number (LUN) of the 
 | 
						|
          discovered logical unit. 
 | 
						|
          A value of zero has no meaning in this case." 
 | 
						|
     ::= { scsiDscLunEntry 2 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   ----------------------- LU Identifiers discovered ------------------ 
 | 
						|
   scsiDscLunIdTable OBJECT-TYPE 
 | 
						|
     SYNTAX           SEQUENCE OF ScsiDscLunIdEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table includes all the known LU Identifiers of the 
 | 
						|
          remote (not in the local system) logical units discovered via 
 | 
						|
          each local initiator port or device of this SCSI instance." 
 | 
						|
     ::= { scsiRemoteTarget 3 } 
 | 
						|
    
 | 
						|
   scsiDscLunIdEntry OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiDscLunIdEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) represents the LU Identifier of a discovered 
 | 
						|
          LUN at a particular SCSI target device (scsiDscTgtIndex), 
 | 
						|
          where the LUN was discovered by a particular local initiator 
 | 
						|
          device within a particular SCSI instance, possibly via a 
 | 
						|
          particular local initiator port." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiDscTgtIntrPortIndex, 
 | 
						|
     scsiDscTgtIndex, scsiDscLunIndex, scsiDscLunIdIndex } 
 | 
						|
     ::= { scsiDscLunIdTable 1 } 
 | 
						|
    
 | 
						|
   ScsiDscLunIdEntry ::= SEQUENCE { 
 | 
						|
     scsiDscLunIdIndex        ScsiIndexValue, 
 | 
						|
     scsiDscLunIdCodeSet      ScsiIdCodeSet, 
 | 
						|
     scsiDscLunIdAssociation  ScsiIdAssociation, 
 | 
						|
     scsiDscLunIdType         ScsiIdType, 
 | 
						|
     scsiDscLunIdValue        ScsiIdValue 
 | 
						|
   } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiDscLunIdIndex     OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object is an arbitrary integer used to uniquely 
 | 
						|
          identify a particular LUN Identifier discovered by each scsi 
 | 
						|
          initiator device or particular SCSI initiator port within a 
 | 
						|
          particular SCSI instance." 
 | 
						|
     ::= { scsiDscLunIdEntry 1 } 
 | 
						|
    
 | 
						|
   scsiDscLunIdCodeSet OBJECT-TYPE 
 | 
						|
     SYNTAX          ScsiIdCodeSet 
 | 
						|
     MAX-ACCESS      read-only 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object specifies the code set in use with this 
 | 
						|
          identifier. 
 | 
						|
          The value is represented in the same format as is contained 
 | 
						|
          in the identifier's Identification Descriptor within the 
 | 
						|
          Logical Unit's Device Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2),Revision 20,   
 | 
						|
          Chapter 8: section 8.4.4, page 210 Vital Product Data 
 | 
						|
          Parameters [16]" 
 | 
						|
     ::= { scsiDscLunIdEntry 2 } 
 | 
						|
    
 | 
						|
   scsiDscLunIdAssociation OBJECT-TYPE 
 | 
						|
     SYNTAX          ScsiIdAssociation  
 | 
						|
     MAX-ACCESS      read-only 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object specifies what the identifier is associated with 
 | 
						|
          (e.g, with the addressed physical/logical device or with a 
 | 
						|
          particular port).  The value is represented in the same 
 | 
						|
          format as is contained in the identifier's Identification 
 | 
						|
          Descriptor within the Logical Unit's Device Identification 
 | 
						|
          Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), Revision 20, 
 | 
						|
          Chapter 8: section 8.4.4, page 210 Vital Product Data 
 | 
						|
          Parameters [16]" 
 | 
						|
     ::= { scsiDscLunIdEntry 3 } 
 | 
						|
    
 | 
						|
   scsiDscLunIdType OBJECT-TYPE 
 | 
						|
     SYNTAX          ScsiIdType 
 | 
						|
     MAX-ACCESS      read-only 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object specifies the type of the identifier.  
 | 
						|
          The value is represented in the same format as is contained 
 | 
						|
          in the identifier's Identification Descriptor within the 
 | 
						|
          Logical Unit's Device Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), Revision 20, 
 | 
						|
          Chapter 8: section 8.4.4, page 210 Vital Product Data 
 | 
						|
          Parameters  [16]" 
 | 
						|
 
 | 
						|
     ::= { scsiDscLunIdEntry 4 } 
 | 
						|
    
 | 
						|
   scsiDscLunIdValue OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIdValue  
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the actual value of this identifier. 
 | 
						|
          The format is defined by the objects scsiDscLunIdCodeSet, 
 | 
						|
          scsiDscLunIdAssociation, scsiDscLunIdType. 
 | 
						|
          The value is represented in the same format as is contained 
 | 
						|
          in the identifier's Identification Descriptor within the 
 | 
						|
          Logical Unit's Device Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), 
 | 
						|
          Chapter 8: section 8.4.4, page 210 Vital Product Data 
 | 
						|
     Parameters  [16]" 
 | 
						|
     ::= { scsiDscLunIdEntry 5 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiAttTgtPortTable OBJECT-TYPE 
 | 
						|
     SYNTAX    SEQUENCE OF ScsiAttTgtPortEntry 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table includes all the remote (not in the local system) 
 | 
						|
          target ports that are currently attached to each local 
 | 
						|
          initiator port of this SCSI instance." 
 | 
						|
     ::= { scsiRemoteTarget 6 } 
 | 
						|
    
 | 
						|
   scsiAttTgtPortEntry OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiAttTgtPortEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
       "An entry (row) represents a remote target port 
 | 
						|
       (scsiAttTgtPortIndex) currently attached to a particular 
 | 
						|
       initiator port (scsiPortIndex) of a particular SCSI initiator 
 | 
						|
       device within a particular SCSI instance." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiPortIndex, 
 | 
						|
     scsiAttTgtPortIndex } 
 | 
						|
   ::= { scsiAttTgtPortTable 1 } 
 | 
						|
    
 | 
						|
   ScsiAttTgtPortEntry ::= SEQUENCE { 
 | 
						|
     scsiAttTgtPortIndex      ScsiIndexValue, 
 | 
						|
     scsiAttTgtPortDscTgtIdx  ScsiIndexValueOrZero, 
 | 
						|
     scsiAttTgtPortName       ScsiName, 
 | 
						|
     scsiAttTgtPortIdentifier ScsiIdentifier 
 | 
						|
   } 
 | 
						|
    
 | 
						|
   scsiAttTgtPortIndex   OBJECT-TYPE 
 | 
						|
 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An arbitrary integer used to uniquely identify a particular 
 | 
						|
          target currently attached to a particular SCSI initiator port 
 | 
						|
          of a particular SCSI initiator device within a particular 
 | 
						|
          SCSI instance." 
 | 
						|
     ::= { scsiAttTgtPortEntry 1 } 
 | 
						|
    
 | 
						|
   scsiAttTgtPortDscTgtIdx    OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValueOrZero 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object contains the value of the scsiAttTgtPortIndex 
 | 
						|
          index variable for the row in the scsiDscTgtTable 
 | 
						|
          representing this currently attached target port.  If the 
 | 
						|
          currently attached target port is not represented in the 
 | 
						|
          scsiDscTgtTable, then the value of this object is zero." 
 | 
						|
     ::= { scsiAttTgtPortEntry 2 } 
 | 
						|
    
 | 
						|
   scsiAttTgtPortName OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiName 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object contains the name of the attached target port." 
 | 
						|
     ::= { scsiAttTgtPortEntry 3 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiAttTgtPortIdentifier OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIdentifier 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object contains the identifier of the attached target 
 | 
						|
          port." 
 | 
						|
     ::= { scsiAttTgtPortEntry 4 } 
 | 
						|
    
 | 
						|
    
 | 
						|
    
 | 
						|
   -- Management Objects regarding target type of scsi devices 
 | 
						|
   --  
 | 
						|
   scsiTgtDevTable OBJECT-TYPE 
 | 
						|
     SYNTAX  SEQUENCE OF ScsiTgtDevEntry 
 | 
						|
     MAX-ACCESS      not-accessible 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table contains information about each local target 
 | 
						|
          device."  
 | 
						|
     ::= { scsiTarget 1 } 
 | 
						|
    
 | 
						|
 
 | 
						|
   scsiTgtDevEntry OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiTgtDevEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) containing information applicable to a 
 | 
						|
          particular local target device within a particular SCSI 
 | 
						|
          instance. " 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex } 
 | 
						|
     ::= { scsiTgtDevTable 1 } 
 | 
						|
    
 | 
						|
   ScsiTgtDevEntry ::= SEQUENCE { 
 | 
						|
     scsiTgtDevNumberOfLUs         Gauge32, 
 | 
						|
     scsiTgtDeviceStatus           INTEGER, 
 | 
						|
     scsiTgtDevNonAccessibleLUs    Gauge32 
 | 
						|
   } 
 | 
						|
    
 | 
						|
   scsiTgtDevNumberOfLUs OBJECT-TYPE 
 | 
						|
     SYNTAX         Gauge32 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object is the number of Logical Units accessible via 
 | 
						|
          this local target device." 
 | 
						|
     ::= { scsiTgtDevEntry 1 } 
 | 
						|
    
 | 
						|
   scsiTgtDeviceStatus   OBJECT-TYPE 
 | 
						|
     SYNTAX         INTEGER { 
 | 
						|
          unknown(1), 
 | 
						|
          available(2), 
 | 
						|
          broken(3), 
 | 
						|
          readying(4), 
 | 
						|
          abnormal(5), 
 | 
						|
          nonAddrFailure(6), 
 | 
						|
          nonAddrFailReadying(7), 
 | 
						|
          nonAddrFailAbnormal(8) 
 | 
						|
     } 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the status of this SCSI device, 
 | 
						|
          summarizing the state of both the addressable devices (i.e., 
 | 
						|
          the logical units) and the non-addressable devices within 
 | 
						|
          this SCSI device: 
 | 
						|
          - unknown(1): This value is used when the status cannot be 
 | 
						|
          determined 
 | 
						|
          - available(2): All addressable and non-addressable devices 
 | 
						|
          within the SCSI device are fully operational (i.e., no 
 | 
						|
          logical units have an abnormal status). 
 | 
						|
          - broken(3): The SCSI device is not operational and cannot be 
 | 
						|
          made operational without external intervention. 
 | 
						|
          - readying(4): One or more logical units within the SCSI 
 | 
						|
          device are being initialized and access to the SCSI device is 
 | 
						|
 
 | 
						|
          temporarily limited (i.e., one or more of the logical unit 
 | 
						|
          have a readying status). 
 | 
						|
          - abnormal(5): One or more addressable devices within the 
 | 
						|
          SCSI device are indicating a status other than available; 
 | 
						|
          nevertheless, the SCSI device is operational (i.e., one or 
 | 
						|
          more of the logical units have an abnormal status). 
 | 
						|
          - nonAddrFailure(6): One or more non-addressable devices 
 | 
						|
          within the SCSI device have failed; nevertheless, the SCSI 
 | 
						|
          device is operational (i.e., no logical units have an 
 | 
						|
          abnormal or readying status). 
 | 
						|
          - nonAddrFailReadying(7): One or more non-addressable devices 
 | 
						|
          within the SCSI device have failed; nevertheless,one or more 
 | 
						|
          logical units within the SCSI device are being initialized 
 | 
						|
          and access to the SCSI device is temporarily limited. 
 | 
						|
          - nonAddrFailAbnormal(8): One or more non-addressable devices 
 | 
						|
          within the SCSI device have failed and one or more 
 | 
						|
          addressable devices within the SCSI device are indicating a 
 | 
						|
          status other than available however the SCSI device is 
 | 
						|
          operational. 
 | 
						|
          " 
 | 
						|
     REFERENCE  
 | 
						|
          "SCSI Controller Commands-2 (SCC-2) standard NCITS.318-1998 
 | 
						|
          6.3.1.8 REPORT STATES service action" 
 | 
						|
     ::= { scsiTgtDevEntry 2} 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiTgtDevNonAccessibleLUs OBJECT-TYPE 
 | 
						|
     SYNTAX         Gauge32 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object is the number of Logical Units existing but not 
 | 
						|
          currently accessible via this local target device." 
 | 
						|
     ::= { scsiTgtDevEntry 3 } 
 | 
						|
    
 | 
						|
   -- Target Port Table 
 | 
						|
   scsiTgtPortTable OBJECT-TYPE 
 | 
						|
     SYNTAX    SEQUENCE OF ScsiTgtPortEntry 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table includes all the local target ports of all the 
 | 
						|
          local target devices." 
 | 
						|
     ::= { scsiTarget 2 } 
 | 
						|
    
 | 
						|
   scsiTgtPortEntry OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiTgtPortEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) containing information applicable to a 
 | 
						|
          particular local target port of a particular local target 
 | 
						|
          device within a particular SCSI instance. " 
 | 
						|
 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiPortIndex} 
 | 
						|
     ::= { scsiTgtPortTable 1 } 
 | 
						|
    
 | 
						|
   ScsiTgtPortEntry ::= SEQUENCE { 
 | 
						|
     scsiTgtPortName          ScsiName, 
 | 
						|
     scsiTgtPortIdentifier    ScsiIdentifier, 
 | 
						|
     scsiTgtPortInCommands    Counter32, 
 | 
						|
     scsiTgtPortWrittenMegaBytes   Counter32, 
 | 
						|
     scsiTgtPortReadMegaBytes Counter32, 
 | 
						|
     scsiTgtPortHSInCommands  Counter64 
 | 
						|
       } 
 | 
						|
    
 | 
						|
   scsiTgtPortName OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiName 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the name of the port assigned for 
 | 
						|
          use in the SCSI protocol." 
 | 
						|
     ::= { scsiTgtPortEntry 1 } 
 | 
						|
    
 | 
						|
   scsiTgtPortIdentifier OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIdentifier 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the identifier of the port in one of 
 | 
						|
          the format(s) appropriate for the type of transport." 
 | 
						|
     ::= { scsiTgtPortEntry 2 } 
 | 
						|
    
 | 
						|
   scsiTgtPortInCommands OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the number of commands received by 
 | 
						|
          this target port." 
 | 
						|
     ::= { scsiTgtPortEntry 3 } 
 | 
						|
      
 | 
						|
           
 | 
						|
   scsiTgtPortWrittenMegaBytes OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the amount of data written in 
 | 
						|
          Megabytes by this target port." 
 | 
						|
     ::= { scsiTgtPortEntry 4 } 
 | 
						|
    
 | 
						|
   scsiTgtPortReadMegaBytes OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the amount of data read in Megabytes 
 | 
						|
          by this target port." 
 | 
						|
     ::= { scsiTgtPortEntry 5 } 
 | 
						|
    
 | 
						|
   scsiTgtPortHSInCommands OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter64 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the number of commands received. 
 | 
						|
          This object provides support for systems that can quickly 
 | 
						|
          generate lots of commands because they run at high speed." 
 | 
						|
     ::= { scsiTgtPortEntry 6 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiRemoteInitiators OBJECT IDENTIFIER ::= { scsiTarget 3 } 
 | 
						|
    
 | 
						|
   -- The scsiAuthorizedIntrTable contains the list of remote initiator 
 | 
						|
   -- ports that are authorized to be attached specific target ports  
 | 
						|
   -- and on which, an administrator would like to keep permanent  
 | 
						|
   -- information and long term statistics even when not currently  
 | 
						|
   -- attached. 
 | 
						|
    
 | 
						|
   scsiAuthorizedIntrTable OBJECT-TYPE 
 | 
						|
     SYNTAX    SEQUENCE OF ScsiAuthorizedIntrEntry 
 | 
						|
     MAX-ACCESS  not-accessible 
 | 
						|
     STATUS      current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table includes all the authorized initiator devices or 
 | 
						|
          ports that may attach a target device or port of the local 
 | 
						|
          SCSI instance. Statistics are kept for each such 
 | 
						|
          authorization; thus, the authorizations should be configured 
 | 
						|
          in the manner, which will cause the desired set of statistics 
 | 
						|
          to be collected and that will determine the correct LUN map." 
 | 
						|
     ::= { scsiRemoteInitiators 1 } 
 | 
						|
    
 | 
						|
   scsiAuthorizedIntrEntry OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiAuthorizedIntrEntry 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) represents a remote initiator port or remote 
 | 
						|
          initiator device that may attach to the local target port or 
 | 
						|
          device within a particular SCSI instance." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiAuthIntrTgtPortIndex, 
 | 
						|
     scsiAuthIntrIndex } 
 | 
						|
     ::= { scsiAuthorizedIntrTable 1 } 
 | 
						|
    
 | 
						|
 
 | 
						|
   ScsiAuthorizedIntrEntry ::= SEQUENCE { 
 | 
						|
     scsiAuthIntrTgtPortIndex      ScsiPortIndexValueOrZero, 
 | 
						|
     scsiAuthIntrIndex             ScsiIndexValue, 
 | 
						|
     scsiAuthIntrDevOrPort         ScsiDeviceOrPort, 
 | 
						|
     scsiAuthIntrName              ScsiName, 
 | 
						|
     scsiAuthIntrLunMapIndex       ScsiIndexValueOrZero, 
 | 
						|
     scsiAuthIntrAttachedTimes     Counter32, 
 | 
						|
     scsiAuthIntrOutCommands       Counter32, 
 | 
						|
     scsiAuthIntrReadMegaBytes     Counter32, 
 | 
						|
     scsiAuthIntrWrittenMegaBytes  Counter32, 
 | 
						|
     scsiAuthIntrHSOutCommands     Counter64, 
 | 
						|
     scsiAuthIntrLastCreation      TimeStamp, 
 | 
						|
     scsiAuthIntrRowStatus         RowStatus 
 | 
						|
     } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiAuthIntrTgtPortIndex   OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiPortIndexValueOrZero 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object contains either the index of the port, or zero 
 | 
						|
          to indicate any port, on the particular local target device." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 1 } 
 | 
						|
    
 | 
						|
   scsiAuthIntrIndex     OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object is an arbitrary integer used to uniquely 
 | 
						|
          identify a SCSI initiator which is authorized to attach to a 
 | 
						|
          particular local target device or port of a particular SCSI 
 | 
						|
          instance." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 2 } 
 | 
						|
    
 | 
						|
   scsiAuthIntrDevOrPort OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiDeviceOrPort 
 | 
						|
     MAX-ACCESS     read-create 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object specifies if this entry refers to a remote 
 | 
						|
          initiator port or a device. 
 | 
						|
          A value of device(1) means that the authorized remote 
 | 
						|
          initiator is a device and includes all its ports. 
 | 
						|
          A value of port(2) means that the authorized remote initiator 
 | 
						|
          is a port." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 3 } 
 | 
						|
    
 | 
						|
   scsiAuthIntrName OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiName 
 | 
						|
     MAX-ACCESS     read-create 
 | 
						|
     STATUS         current 
 | 
						|
 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the name of the remote initiator 
 | 
						|
          device or port authorized by this row." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 4 } 
 | 
						|
    
 | 
						|
   scsiAuthIntrLunMapIndex OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValueOrZero 
 | 
						|
     MAX-ACCESS     read-create 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object identifies the set of entries in the 
 | 
						|
          scsiLunMapTable for which scsiLunMapIndex has the same value 
 | 
						|
          as the value of this object.  The identified set of entries 
 | 
						|
          constitute the LUN map to be used for accessing logical units 
 | 
						|
          when the remote initiator port or device corresponding to 
 | 
						|
          this entry is attached to any local target port or device 
 | 
						|
          corresponding to this entry. 
 | 
						|
          Note that this object has a value of zero if this entry 
 | 
						|
          should use the default LUN map." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 5 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiAuthIntrAttachedTimes  OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Times" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object indicates the number of times that this remote 
 | 
						|
          initiator has transitioned from unattached to attached to 
 | 
						|
          this local target device or port." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 6 }   
 | 
						|
      
 | 
						|
   scsiAuthIntrOutCommands    OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object indicates the number of commands that the remote 
 | 
						|
          initiator corresponding to this entry has sent to the local 
 | 
						|
          target device or port corresponding to this entry." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 7 } 
 | 
						|
 
 | 
						|
   scsiAuthIntrReadMegaBytes  OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object indicates the amount of data in Megabytes that 
 | 
						|
          the remote initiator corresponding to this entry has read 
 | 
						|
 
 | 
						|
          from the local target device or port corresponding to this 
 | 
						|
          entry." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 8 } 
 | 
						|
    
 | 
						|
   scsiAuthIntrWrittenMegaBytes    OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object indicates the amount of data in Megabytes that 
 | 
						|
          the remote initiator corresponding to this entry has written 
 | 
						|
          from the local target device or port corresponding to this 
 | 
						|
          entry." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 9} 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiAuthIntrHSOutCommands  OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter64 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents the number of commands sent by the 
 | 
						|
          remote initiator corresponding to this entry to the local 
 | 
						|
          target device or port corresponding to this entry. This 
 | 
						|
          object provides support for systems which can quickly 
 | 
						|
          generate lots of commands because they run at high speed." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 10 } 
 | 
						|
    
 | 
						|
   scsiAuthIntrLastCreation   OBJECT-TYPE 
 | 
						|
     SYNTAX         TimeStamp 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object indicates the value of sysUpTime when this row 
 | 
						|
          was last created." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 11 } 
 | 
						|
             
 | 
						|
   scsiAuthIntrRowStatus OBJECT-TYPE 
 | 
						|
     SYNTAX         RowStatus 
 | 
						|
     MAX-ACCESS     read-create 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object allows an administrator to create or delete this 
 | 
						|
          entry." 
 | 
						|
     ::= { scsiAuthorizedIntrEntry 12 } 
 | 
						|
    
 | 
						|
   scsiAttIntrPrtTable OBJECT-TYPE 
 | 
						|
     SYNTAX  SEQUENCE OF ScsiAttIntrPrtEntry 
 | 
						|
     MAX-ACCESS      not-accessible 
 | 
						|
     STATUS          current 
 | 
						|
 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table includes all the remote initiator ports that are 
 | 
						|
          currently attached to a local target port of all local 
 | 
						|
          devices within all SCSI instances." 
 | 
						|
     ::= { scsiRemoteInitiators 2 } 
 | 
						|
    
 | 
						|
   scsiAttIntrPrtEntry OBJECT-TYPE 
 | 
						|
     SYNTAX          ScsiAttIntrPrtEntry 
 | 
						|
     MAX-ACCESS      not-accessible 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) represents a remote initiator currently 
 | 
						|
          attached to a particular local target port of a particular 
 | 
						|
          target device of a particular SCSI instance." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiPortIndex, 
 | 
						|
     scsiAttIntrPrtIdx } 
 | 
						|
     ::= { scsiAttIntrPrtTable 1 } 
 | 
						|
    
 | 
						|
   ScsiAttIntrPrtEntry ::= SEQUENCE { 
 | 
						|
     scsiAttIntrPrtIdx             ScsiIndexValue, 
 | 
						|
     scsiAttIntrPrtAuthIntrIdx     ScsiIndexValueOrZero, 
 | 
						|
     scsiAttIntrPrtName            ScsiName, 
 | 
						|
     scsiAttIntrPrtId              ScsiIdentifier 
 | 
						|
       } 
 | 
						|
    
 | 
						|
   scsiAttIntrPrtIdx OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents an arbitrary integer used to 
 | 
						|
          uniquely identify a particular attached remote initiator port 
 | 
						|
          to a particular target port within a particular SCSI target 
 | 
						|
          device within a particular SCSI instance." 
 | 
						|
     ::= { scsiAttIntrPrtEntry 1 } 
 | 
						|
    
 | 
						|
   scsiAttIntrPrtAuthIntrIdx OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValueOrZero 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object is the corresponding index in the 
 | 
						|
          scsiAuthorizedIntrTable for this current attached remote 
 | 
						|
          initiator or zero if this remote attached initiator is not 
 | 
						|
          configured in that table." 
 | 
						|
     ::= { scsiAttIntrPrtEntry 2 } 
 | 
						|
    
 | 
						|
   scsiAttIntrPrtName OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiName 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
 
 | 
						|
          " This object represents the name of the remote initiator 
 | 
						|
          attached to this local target port." 
 | 
						|
     ::= { scsiAttIntrPrtEntry 3 } 
 | 
						|
    
 | 
						|
   scsiAttIntrPrtId OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIdentifier 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the identifier of the remote 
 | 
						|
          initiator attached to this local target port." 
 | 
						|
     ::= { scsiAttIntrPrtEntry 4 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   ------------------- Managed Objects regarding logical units -------- 
 | 
						|
   scsiLuTable OBJECT-TYPE 
 | 
						|
     SYNTAX         SEQUENCE OF ScsiLuEntry 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This table contains all the logical units exposed by local 
 | 
						|
          target devices." 
 | 
						|
     ::= { scsiLogicalUnit 1 } 
 | 
						|
    
 | 
						|
   scsiLuEntry OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiLuEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) contains information applicable to a 
 | 
						|
          particular logical unit of a particular local target device 
 | 
						|
          within a particular SCSI instance. " 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiLuIndex} 
 | 
						|
     ::= { scsiLuTable 1 } 
 | 
						|
    
 | 
						|
   ScsiLuEntry ::= SEQUENCE { 
 | 
						|
     scsiLuIndex              ScsiIndexValue, 
 | 
						|
     scsiLuDefaultLun         ScsiLUNOrZero, 
 | 
						|
     scsiLuWwnName            ScsiNameIdOrZero, 
 | 
						|
     scsiLuVendorId           SnmpAdminString, 
 | 
						|
     scsiLuProductId          SnmpAdminString, 
 | 
						|
     scsiLuRevisionId         SnmpAdminString, 
 | 
						|
     scsiLuPeripheralType     Unsigned32, 
 | 
						|
     scsiLuStatus             INTEGER, 
 | 
						|
     scsiLuState              BITS, 
 | 
						|
     scsiLuInCommands         Counter32, 
 | 
						|
     scsiLuReadMegaBytes      Counter32, 
 | 
						|
     scsiLuWrittenMegaBytes   Counter32, 
 | 
						|
     scsiLuInResets           Counter32, 
 | 
						|
     scsiLuOutQueueFullStatus Counter32, 
 | 
						|
     scsiLuHSInCommands       Counter64 
 | 
						|
   } 
 | 
						|
    
 | 
						|
 
 | 
						|
   scsiLuIndex OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents an arbitrary integer used to 
 | 
						|
          uniquely identify a particular logical unit within a 
 | 
						|
          particular SCSI target device within a particular SCSI 
 | 
						|
          instance." 
 | 
						|
     ::= { scsiLuEntry 1 } 
 | 
						|
    
 | 
						|
   scsiLuDefaultLun OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiLUNOrZero 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the default Logical Unit Number 
 | 
						|
          (LUN) for this logical unit; it is the LUN that will appear 
 | 
						|
          to an initiator that was not configured to see another LUN.  
 | 
						|
          Note that this object will have a zero-length string if this 
 | 
						|
          Logical Unit does not have a default LUN." 
 | 
						|
     ::= { scsiLuEntry 2 } 
 | 
						|
    
 | 
						|
   scsiLuWwnName OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiNameIdOrZero 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the World-Wide Name of this LU. 
 | 
						|
          A value of zero has no meaning in this case." 
 | 
						|
     ::= { scsiLuEntry 3 } 
 | 
						|
    
 | 
						|
   scsiLuVendorId   OBJECT-TYPE 
 | 
						|
     SYNTAX         SnmpAdminString(SIZE(0..79)) 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents a string identifying the vendor of 
 | 
						|
          this LU according to the value in SCSI device page." 
 | 
						|
     ::= { scsiLuEntry 4 } 
 | 
						|
    
 | 
						|
   scsiLuProductId  OBJECT-TYPE 
 | 
						|
     SYNTAX         SnmpAdminString(SIZE(0..79)) 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents a string identifying the product for 
 | 
						|
          this LU according to the value in SCSI device page." 
 | 
						|
     ::= { scsiLuEntry 5 } 
 | 
						|
    
 | 
						|
   scsiLuRevisionId OBJECT-TYPE 
 | 
						|
     SYNTAX         SnmpAdminString(SIZE(0..79)) 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object represents a string defining the product 
 | 
						|
          revision of this LU according to the value in SCSI device 
 | 
						|
          page." 
 | 
						|
     ::= { scsiLuEntry 6 } 
 | 
						|
    
 | 
						|
   scsiLuPeripheralType  OBJECT-TYPE 
 | 
						|
     SYNTAX         Unsigned32 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object is the value returned to SCSI query VPD page 83. 
 | 
						|
          It can be: direct-access device, sequential-access device, 
 | 
						|
          printer, communication device and so on.  
 | 
						|
          The values that can be returned here are defined in SCSI 
 | 
						|
          Primary Commands -2." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), T10 Project 1236-
 | 
						|
          D, Revision 20, 18 July 2001  [16]" 
 | 
						|
     ::= { scsiLuEntry 7 } 
 | 
						|
    
 | 
						|
   scsiLuStatus     OBJECT-TYPE 
 | 
						|
     SYNTAX         INTEGER { 
 | 
						|
               unknown(1), 
 | 
						|
               available(2), 
 | 
						|
               notAvailable(3), 
 | 
						|
               broken(4), 
 | 
						|
               readying(5), 
 | 
						|
               abnormal(6) 
 | 
						|
          } 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the status of this logical unit: 
 | 
						|
          - unknown(1): The status of this logical unit cannot be 
 | 
						|
          determined. 
 | 
						|
          - available(2): The logical unit is fully operational (i.e., 
 | 
						|
          accepts media access SCSI commands and has no state 
 | 
						|
          information to report). 
 | 
						|
          - notAvailable(3): The logical unit is capable of being 
 | 
						|
          supported but not available (i.e., no logical unit is 
 | 
						|
          currently present or the logical unit is present but not 
 | 
						|
          configured for use). 
 | 
						|
          - broken(4): The logical unit has failed and cannot respond 
 | 
						|
          to SCSI commands. 
 | 
						|
          - readying(5): The logical unit is being initialized and 
 | 
						|
          access is temporarily limited. 
 | 
						|
          - abnormal(6): The logical unit has state information 
 | 
						|
          available that indicates it is operating with limits. The 
 | 
						|
          scsiLuState indicates what those limits are. 
 | 
						|
     " 
 | 
						|
     REFERENCE  
 | 
						|
 
 | 
						|
          " SCSI Controller Commands-2 (SCC-2) standard NCITS.318-1998 
 | 
						|
          6.3.1.8 REPORT STATES service action" 
 | 
						|
     ::= { scsiLuEntry 8 } 
 | 
						|
    
 | 
						|
   scsiLuState OBJECT-TYPE 
 | 
						|
     SYNTAX         BITS { 
 | 
						|
               dataLost(0), 
 | 
						|
               dynamicReconfigurationInProgress(1), 
 | 
						|
               exposed(2), 
 | 
						|
               fractionallyExposed(3), 
 | 
						|
               partiallyExposed(4), 
 | 
						|
               protectedRebuild(5), 
 | 
						|
               protectionDisabled(6), 
 | 
						|
               rebuild(7), 
 | 
						|
               recalculate(8), 
 | 
						|
               spareInUse(9), 
 | 
						|
               verifyInProgress(10) 
 | 
						|
          }  
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the state of a logical unit and its 
 | 
						|
          meaning is according the bit position: 
 | 
						|
          0    Data lost: Within the logical unit data has been lost. 
 | 
						|
          1    Dynamic reconfiguration in progress: The logical unit is 
 | 
						|
               being reconfigured. In this state all data is still 
 | 
						|
               protected. 
 | 
						|
          2    Exposed: Within the logical unit data is not protected. 
 | 
						|
               In this state all data is still valid, however, loss of 
 | 
						|
               data/data-availability is unavoidable in the event of a 
 | 
						|
               failure. 
 | 
						|
          3    Fractionally exposed: Within the logical unit part of 
 | 
						|
               the data is not protected. In this state all data is 
 | 
						|
               still valid, however, a failure may cause a loss of data 
 | 
						|
               or a loss of data availability. 
 | 
						|
          4    Partially exposed: Within the logical unit one or more 
 | 
						|
               underlying storage devices have failed. In this state 
 | 
						|
               all data is still protected. 
 | 
						|
          5    Protected rebuild: The logical unit is in the process of 
 | 
						|
               a rebuild operation. In this state all data is 
 | 
						|
               protected. 
 | 
						|
          6    Protection disabled: Within the logical unit the data 
 | 
						|
               protection method has been disabled. 
 | 
						|
               In this state all data is still valid, however, however, 
 | 
						|
               loss of data/data-availability is unavoidable in the 
 | 
						|
               event of a failure. 
 | 
						|
          7    Rebuild: The data protection method is in the process of 
 | 
						|
               rebuilding data. In this state data is not protected. 
 | 
						|
          8    Recalculate: The logical unit is in the process of a 
 | 
						|
               recalculate operation. 
 | 
						|
          9    Spare in use: Within the logical unit a storage device 
 | 
						|
               in full or part being used to store data. In this state 
 | 
						|
               all data is still protected. 
 | 
						|
 
 | 
						|
          10   Verify in progress: Within the logical unit data is 
 | 
						|
               being verified." 
 | 
						|
     REFERENCE  
 | 
						|
          " SCSI Controller Commands-2 (SCC-2) standard NCITS.318-1998 
 | 
						|
          6.3.1.8 REPORT STATES service action" 
 | 
						|
     ::= { scsiLuEntry 9 } 
 | 
						|
    
 | 
						|
   scsiLuInCommands OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the number of commands received by 
 | 
						|
          this logical unit." 
 | 
						|
     ::= { scsiLuEntry 10 } 
 | 
						|
      
 | 
						|
   scsiLuReadMegaBytes OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the amount of data in Megabytes read 
 | 
						|
          from this logical unit." 
 | 
						|
     ::= { scsiLuEntry 11 } 
 | 
						|
    
 | 
						|
   scsiLuWrittenMegaBytes OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "Megabytes" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the amount of data in Megabytes 
 | 
						|
          written by this logical unit." 
 | 
						|
     ::= { scsiLuEntry 12 } 
 | 
						|
    
 | 
						|
   scsiLuInResets OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     UNITS          "resets" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the number of resets received by 
 | 
						|
          this logical unit." 
 | 
						|
     ::= { scsiLuEntry 13 } 
 | 
						|
           
 | 
						|
    
 | 
						|
   scsiLuOutQueueFullStatus   OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter32 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
 
 | 
						|
          " This object represents the number of queue full statuses 
 | 
						|
          received by this logical unit." 
 | 
						|
     ::= { scsiLuEntry 14 } 
 | 
						|
    
 | 
						|
   scsiLuHSInCommands OBJECT-TYPE 
 | 
						|
     SYNTAX         Counter64 
 | 
						|
     UNITS          "commands" 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the number of commands received by 
 | 
						|
          this logical unit. This object provides support for systems 
 | 
						|
          that can quickly generate lots of commands because they run 
 | 
						|
          at high speed." 
 | 
						|
     ::= { scsiLuEntry 15 } 
 | 
						|
    
 | 
						|
   ----------------------- Logical Unit Identifier Table --------------
 | 
						|
           
 | 
						|
   scsiLuIdTable OBJECT-TYPE 
 | 
						|
     SYNTAX  SEQUENCE OF ScsiLuIdEntry 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "A table of identifiers for all logical units exposed by 
 | 
						|
          local targets device." 
 | 
						|
     ::= { scsiLogicalUnit 2 } 
 | 
						|
    
 | 
						|
   scsiLuIdEntry OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiLuIdEntry 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "An entry (row) containing information applicable to a 
 | 
						|
          particular identifier for a particular logical unit of a 
 | 
						|
          particular target device within a particular SCSI instance. " 
 | 
						|
     INDEX {scsiInstIndex, scsiDeviceIndex, scsiLuIndex, scsiLuIdIndex} 
 | 
						|
     ::= { scsiLuIdTable 1 } 
 | 
						|
    
 | 
						|
   ScsiLuIdEntry ::= SEQUENCE { 
 | 
						|
     scsiLuIdIndex       ScsiIndexValue, 
 | 
						|
     scsiLuIdCodeSet     ScsiIdCodeSet, 
 | 
						|
     scsiLuIdAssociation ScsiIdAssociation, 
 | 
						|
     scsiLuIdType        ScsiIdType, 
 | 
						|
     scsiLuIdValue       ScsiIdValue 
 | 
						|
     } 
 | 
						|
    
 | 
						|
   scsiLuIdIndex    OBJECT-TYPE 
 | 
						|
     SYNTAX          ScsiIndexValue 
 | 
						|
     MAX-ACCESS      not-accessible 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents an arbitrary integer used to 
 | 
						|
          uniquely identify a particular LU Identifier within a 
 | 
						|
 
 | 
						|
          particular logical unit within a particular SCSI target 
 | 
						|
          device within a particular SCSI instance." 
 | 
						|
     ::= { scsiLuIdEntry 1 } 
 | 
						|
    
 | 
						|
   scsiLuIdCodeSet OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiIdCodeSet  
 | 
						|
     MAX-ACCESS       read-only 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object specifies the code set in use with this 
 | 
						|
          identifier. 
 | 
						|
          The value is represented in the same format as is contained 
 | 
						|
          in the identifier's Identification Descriptor within the 
 | 
						|
          Logical Unit's Device Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 ((SPC-2), Revision 20,   
 | 
						|
          Chapter 8: section 8.4.4, page 210 Vital Product Data 
 | 
						|
          Parameters [16]" 
 | 
						|
     ::= { scsiLuIdEntry 2 } 
 | 
						|
    
 | 
						|
   scsiLuIdAssociation OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiIdAssociation 
 | 
						|
     MAX-ACCESS       read-only 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object specifies what the identifier is associated with 
 | 
						|
          (e.g, with the addressed physical/logical device or with a 
 | 
						|
          particular port).  The value is represented in the same 
 | 
						|
          format as is contained in the identifier's Identification 
 | 
						|
          Descriptor within the Logical Unit's Device Identification 
 | 
						|
          Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), Revision 20, 
 | 
						|
          Chapter 8: section 8.4.4, page 210 Vital Product Data 
 | 
						|
          Parameters [16]" 
 | 
						|
     ::= { scsiLuIdEntry 3 } 
 | 
						|
    
 | 
						|
   scsiLuIdType     OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiIdType  
 | 
						|
     MAX-ACCESS       read-only 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object specifies the type of the identifier.  
 | 
						|
          The value is represented in the same format as is contained 
 | 
						|
          in the identifier's Identification Descriptor within the 
 | 
						|
          Logical Unit's Device Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), Revision 20, 
 | 
						|
          Chapter 8: section 8.4.4, page 210 Vital Product Data 
 | 
						|
          Parameters  [16]" 
 | 
						|
     ::= { scsiLuIdEntry 4 } 
 | 
						|
    
 | 
						|
   scsiLuIdValue OBJECT-TYPE 
 | 
						|
 
 | 
						|
     SYNTAX         ScsiIdValue 
 | 
						|
     MAX-ACCESS     read-only 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents the actual value of this identifier. 
 | 
						|
          The format is defined by the objects scsiLuIdCodeSet, 
 | 
						|
          scsiLuIdAssociation, scsiLuIdType. 
 | 
						|
          The value is represented in the same format as is contained 
 | 
						|
          in the identifier's Identification Descriptor within the 
 | 
						|
          Logical Unit's Device Identification Page." 
 | 
						|
     REFERENCE  
 | 
						|
          " ANSI - SCSI Primary Commands - 2 (SPC-2), 
 | 
						|
          Chapter 8: section 8.4.4, page 210 Vital Product Data 
 | 
						|
     Parameters  [16]" 
 | 
						|
   ::= { scsiLuIdEntry 5 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   ----------------------- The LUN Map Table -------------------------- 
 | 
						|
    
 | 
						|
   scsiLunMapTable OBJECT-TYPE 
 | 
						|
     SYNTAX    SEQUENCE OF ScsiLunMapEntry 
 | 
						|
     MAX-ACCESS     not-accessible 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This table includes LUNs additional to the default one. A 
 | 
						|
          logical unit may have a different Logical Unit Number for 
 | 
						|
          different initiators. This table provides a mapping between a 
 | 
						|
          logical unit and a logical unit number." 
 | 
						|
     ::= { scsiLogicalUnit 3 } 
 | 
						|
    
 | 
						|
   scsiLunMapEntry OBJECT-TYPE 
 | 
						|
     SYNTAX          ScsiLunMapEntry 
 | 
						|
     MAX-ACCESS      not-accessible 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
       "An entry containing information about the mapping of a 
 | 
						|
       particular Logical Unit to a particular LUN.  The set of 
 | 
						|
       entries which all have the same values of scsiInstIndex, 
 | 
						|
       scsiDeviceIndex and scsiLunMapIndex constitute a LUN Map within 
 | 
						|
       a particular SCSI instance." 
 | 
						|
     INDEX { scsiInstIndex, scsiDeviceIndex, scsiLunMapIndex, 
 | 
						|
     scsiLunMapLun} 
 | 
						|
     ::= { scsiLunMapTable 1 } 
 | 
						|
    
 | 
						|
   ScsiLunMapEntry ::= SEQUENCE { 
 | 
						|
     scsiLunMapIndex     ScsiIndexValue, 
 | 
						|
     scsiLunMapLun       ScsiLUNOrZero, 
 | 
						|
     scsiLunMapLuIndex   ScsiIndexValue, 
 | 
						|
     scsiLunMapRowStatus RowStatus 
 | 
						|
     } 
 | 
						|
    
 | 
						|
   scsiLunMapIndex  OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiIndexValue 
 | 
						|
 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " This object represents an arbitrary integer used to 
 | 
						|
          uniquely identify a particular LunMap within a particular 
 | 
						|
          SCSI target device within a particular SCSI instance." 
 | 
						|
     ::= { scsiLunMapEntry 1 } 
 | 
						|
    
 | 
						|
   scsiLunMapLun    OBJECT-TYPE 
 | 
						|
     SYNTAX           ScsiLUNOrZero 
 | 
						|
     MAX-ACCESS       not-accessible 
 | 
						|
     STATUS           current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object specifies the Logical Unit Number, to which a 
 | 
						|
          logical unit is mapped by this row. 
 | 
						|
          A value of zero has no meaning in this case." 
 | 
						|
     ::= { scsiLunMapEntry 2 } 
 | 
						|
    
 | 
						|
   scsiLunMapLuIndex OBJECT-TYPE 
 | 
						|
     SYNTAX         ScsiIndexValue 
 | 
						|
     MAX-ACCESS     read-create 
 | 
						|
     STATUS         current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object identifies the logical unit for which the value 
 | 
						|
          of scsiLuIndex is the same as the value of this object.  The 
 | 
						|
          identified logical unit is the one mapped to a LUN by this 
 | 
						|
          row." 
 | 
						|
     ::= { scsiLunMapEntry 3 } 
 | 
						|
    
 | 
						|
   scsiLunMapRowStatus   OBJECT-TYPE 
 | 
						|
     SYNTAX          RowStatus 
 | 
						|
     MAX-ACCESS      read-create 
 | 
						|
     STATUS          current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This object allows an administrator to create and delete 
 | 
						|
          this entry." 
 | 
						|
     ::= { scsiLunMapEntry 4 } 
 | 
						|
    
 | 
						|
    
 | 
						|
    
 | 
						|
   -- Notifications 
 | 
						|
   -- scsiNotifications OBJECT IDENTIFIER ::= { scsiModule 2 } 
 | 
						|
   scsiNotificationsPrefix OBJECT IDENTIFIER  
 | 
						|
     ::= { scsiNotifications 0 } 
 | 
						|
    
 | 
						|
   scsiTgtDeviceStatusChanged NOTIFICATION-TYPE 
 | 
						|
     OBJECTS { scsiTgtDeviceStatus } 
 | 
						|
     STATUS  current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " A notification will be generated for each occurrence of the 
 | 
						|
          abnormal status (e.g., if the SCSI target device's current 
 | 
						|
          status is abnormal) providing that the SCSI instance's value 
 | 
						|
          of scsiInstScsiNotificationsEnable is enabled. 
 | 
						|
 
 | 
						|
          An SNMP agent implementing the SCSI MIB should not send more 
 | 
						|
          than three SCSI identical notifications in any 10-second 
 | 
						|
          period." 
 | 
						|
     ::= { scsiNotificationsPrefix 1 } 
 | 
						|
    
 | 
						|
   scsiLuStatusChanged NOTIFICATION-TYPE 
 | 
						|
     OBJECTS { scsiLuStatus } 
 | 
						|
     STATUS  current 
 | 
						|
     DESCRIPTION 
 | 
						|
          " A notification will be generated each time that 
 | 
						|
          scsiLuStatus will change providing that the SCSI instance's 
 | 
						|
          value of scsiInstScsiNotificationsEnable is enabled. 
 | 
						|
          An SNMP agent implementing the SCSI MIB should not send more 
 | 
						|
          than three SCSI identical notifications in any 10-second 
 | 
						|
          period." 
 | 
						|
     ::= { scsiNotificationsPrefix 2 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   -- The next part defines the conformance groups in use for SCSI MIB. 
 | 
						|
   scsiCompliances OBJECT IDENTIFIER ::= { scsiConformance 1 } 
 | 
						|
    
 | 
						|
   scsiCompliance MODULE-COMPLIANCE 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "Describes the requirements for compliance to this SCSI MIB. 
 | 
						|
          If an implementation can be both a target and an initiator, 
 | 
						|
          all groups are mandatory." 
 | 
						|
     MODULE  -- this module 
 | 
						|
          MANDATORY-GROUPS { 
 | 
						|
               scsiDeviceGroup                
 | 
						|
                              } 
 | 
						|
      
 | 
						|
     OBJECT scsiInstAlias 
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not mandatory." 
 | 
						|
           
 | 
						|
     OBJECT scsiInstScsiNotificationsEnable 
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not mandatory." 
 | 
						|
           
 | 
						|
     OBJECT scsiDeviceAlias 
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not mandatory." 
 | 
						|
    
 | 
						|
   -- Conditionally mandatory groups to be included with 
 | 
						|
   -- the mandatory groups when the implementation has 
 | 
						|
   -- SCSI target device. 
 | 
						|
      
 | 
						|
     GROUP scsiTargetGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
 
 | 
						|
          "This group is mandatory for all SCSI implementations that 
 | 
						|
          have SCSI target devices." 
 | 
						|
     GROUP scsiLunMapGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for system having the capabilities 
 | 
						|
          of mapping local targets and logical units according remote 
 | 
						|
          initiators." 
 | 
						|
    
 | 
						|
     OBJECT scsiAuthIntrDevOrPort 
 | 
						|
     MIN-ACCESS     read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not required." 
 | 
						|
      
 | 
						|
     OBJECT scsiAuthIntrName 
 | 
						|
     MIN-ACCESS     read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not required." 
 | 
						|
      
 | 
						|
     OBJECT scsiAuthIntrLunMapIndex 
 | 
						|
     MIN-ACCESS     read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not required." 
 | 
						|
      
 | 
						|
     OBJECT scsiAuthIntrRowStatus 
 | 
						|
     SYNTAX RowStatus
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not required, and only one of the six 
 | 
						|
          enumerated values for the RowStatus textual convention need 
 | 
						|
          be supported, specifically: active(1)."            
 | 
						|
    
 | 
						|
    
 | 
						|
   -- Conditionally mandatory groups to be included with 
 | 
						|
   -- the mandatory groups when the implementation has 
 | 
						|
   -- SCSI initiator device. 
 | 
						|
    
 | 
						|
     GROUP scsiInitiatorGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for all SCSI implementations that 
 | 
						|
          have SCSI initiator devices." 
 | 
						|
    
 | 
						|
     OBJECT scsiIntrDevTgtAccessMode 
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION "Write access is not mandatory." 
 | 
						|
    
 | 
						|
     GROUP scsiDiscoveryGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for system having the capabilities 
 | 
						|
          of discovering remote targets via local initiators." 
 | 
						|
    
 | 
						|
     OBJECT scsiLunMapLuIndex 
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
 
 | 
						|
          "Write access is not mandatory." 
 | 
						|
           
 | 
						|
     OBJECT scsiLunMapRowStatus 
 | 
						|
     SYNTAX RowStatus
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not required, and only one of the six 
 | 
						|
          enumerated values for the RowStatus textual convention need 
 | 
						|
          be supported, specifically: active(1)." 
 | 
						|
           
 | 
						|
     OBJECT scsiDscTgtDevOrPort 
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not mandatory." 
 | 
						|
           
 | 
						|
     OBJECT scsiDscTgtName 
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION "Write access is not mandatory." 
 | 
						|
    
 | 
						|
     OBJECT scsiDscTgtConfigured  
 | 
						|
     SYNTAX TruthValue
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "The value of true(1) is not mandatory neither the write 
 | 
						|
          access." 
 | 
						|
      
 | 
						|
     OBJECT scsiDscTgtRowStatus 
 | 
						|
     SYNTAX RowStatus
 | 
						|
     MIN-ACCESS read-only 
 | 
						|
     DESCRIPTION  
 | 
						|
          "Write access is not required, and only one of the six 
 | 
						|
          enumerated values for the RowStatus textual convention need 
 | 
						|
          be supported, specifically: active(1)."            
 | 
						|
    
 | 
						|
   -- Conditionally mandatory groups to be included with the mandatory  
 | 
						|
   -- groups when the implementation can gather statistics. 
 | 
						|
     GROUP scsiDeviceStatGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for all SCSI implementations that 
 | 
						|
          can gather statistics." 
 | 
						|
      
 | 
						|
   -- Conditionally mandatory groups to be included with the mandatory  
 | 
						|
   -- groups when the implementation can gather statistics at the SCSI 
 | 
						|
   -- initiator side. 
 | 
						|
     GROUP scsiInitiatorStatsGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for all SCSI implementations that 
 | 
						|
          can gather statistics at SCSI initiator side." 
 | 
						|
     GROUP scsiDiscoveryStatsGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for system having the capabilities 
 | 
						|
          of gathering statistics regarding remote targets via local 
 | 
						|
          initiators."    
 | 
						|
 
 | 
						|
    
 | 
						|
   -- Conditionally mandatory groups to be included with the mandatory  
 | 
						|
   -- groups when the implementation can gather statistics at the SCSI 
 | 
						|
   -- target side. 
 | 
						|
     GROUP scsiTargetStatsGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for all SCSI implementations that 
 | 
						|
          can gather statistics at SCSI target devices." 
 | 
						|
     GROUP scsiLunMapStatsGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for SCSI implementations able to map 
 | 
						|
          local targets and logical units according remote initiators." 
 | 
						|
    
 | 
						|
   -- Conditionally mandatory groups to be included with the mandatory  
 | 
						|
   -- groups when the implementation is running at high speed and can  
 | 
						|
   -- gather statistics at the SCSI initiator side. 
 | 
						|
     GROUP scsiInitiatorHSStatsGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for all SCSI implementations that 
 | 
						|
          can gather statistics at SCSI initiator side and are running 
 | 
						|
          at high speed." 
 | 
						|
     GROUP scsiDiscoveryHSStatsGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for system having the capabilities 
 | 
						|
          of gathering statistics regarding remote targets via local 
 | 
						|
          initiators and are running at high speed."    
 | 
						|
    
 | 
						|
   -- Conditionally mandatory groups to be included with the mandatory  
 | 
						|
   -- groups when the implementation  is running at high speed and can 
 | 
						|
   -- gather statistics at the SCSI target side. 
 | 
						|
     GROUP scsiTargetHSStatsGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for all SCSI implementations that 
 | 
						|
          can gather statistics at SCSI target devices in high speed 
 | 
						|
          system." 
 | 
						|
     GROUP scsiLunMapHSStatsGroup 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is mandatory for SCSI implementations able to map 
 | 
						|
          local targets and logical units according remote initiators 
 | 
						|
          in high speed system." 
 | 
						|
     ::= { scsiCompliances 1 } 
 | 
						|
    
 | 
						|
   scsiGroups OBJECT IDENTIFIER ::= { scsiConformance 2 } 
 | 
						|
    
 | 
						|
   scsiDeviceGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiInstAlias,  
 | 
						|
          scsiInstSoftwareIndex,  
 | 
						|
          scsiInstVendorVersion, 
 | 
						|
          scsiInstScsiNotificationsEnable, 
 | 
						|
          scsiDeviceAlias,              
 | 
						|
          scsiDeviceRole,
 | 
						|
          scsiDevicePortNumber, 
 | 
						|
 
 | 
						|
          scsiPortRole,  
 | 
						|
          scsiPortTrnsptPtr, 
 | 
						|
          scsiTrnsptType,  
 | 
						|
          scsiTrnsptPointer,  
 | 
						|
          scsiTrnsptDevName 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "A collection of objects providing information about SCSI 
 | 
						|
          instances, devices and ports." 
 | 
						|
     ::= { scsiGroups 1 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiInitiatorGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiIntrDevTgtAccessMode, 
 | 
						|
          scsiIntrPrtName,  
 | 
						|
          scsiIntrPrtIdentifier, 
 | 
						|
          scsiAttTgtPortDscTgtIdx, 
 | 
						|
          scsiAttTgtPortName,  
 | 
						|
          scsiAttTgtPortIdentifier 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is relevant for an initiator device and port." 
 | 
						|
     ::= { scsiGroups 2 } 
 | 
						|
    
 | 
						|
   scsiDiscoveryGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiDscTgtDevOrPort, 
 | 
						|
          scsiDscTgtName,  
 | 
						|
          scsiDscTgtConfigured,  
 | 
						|
          scsiDscTgtDiscovered, 
 | 
						|
          scsiDscTgtRowStatus, 
 | 
						|
          scsiDscTgtLastCreation, 
 | 
						|
          scsiDscLunLun, 
 | 
						|
          scsiDscLunIdCodeSet, 
 | 
						|
          scsiDscLunIdAssociation, 
 | 
						|
          scsiDscLunIdType, 
 | 
						|
          scsiDscLunIdValue 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is relevant for the discovered targets by an 
 | 
						|
          initiator port." 
 | 
						|
     ::= { scsiGroups 3 } 
 | 
						|
    
 | 
						|
   scsiTargetGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiTgtDevNumberOfLUs, 
 | 
						|
          scsiTgtDeviceStatus, 
 | 
						|
          scsiTgtDevNonAccessibleLUs, 
 | 
						|
          scsiTgtPortName, 
 | 
						|
 
 | 
						|
          scsiTgtPortIdentifier, 
 | 
						|
          scsiAttIntrPrtAuthIntrIdx, 
 | 
						|
          scsiAttIntrPrtName, 
 | 
						|
          scsiAttIntrPrtId, 
 | 
						|
          scsiLuDefaultLun, 
 | 
						|
          scsiLuWwnName,  
 | 
						|
          scsiLuVendorId,           
 | 
						|
          scsiLuProductId,     
 | 
						|
          scsiLuRevisionId, 
 | 
						|
          scsiLuPeripheralType, 
 | 
						|
          scsiLuStatus, 
 | 
						|
          scsiLuState, 
 | 
						|
          scsiLuIdCodeSet, 
 | 
						|
          scsiLuIdAssociation, 
 | 
						|
          scsiLuIdType, 
 | 
						|
          scsiLuIdValue 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "This group is relevant for a target device and port." 
 | 
						|
     ::= { scsiGroups 4 } 
 | 
						|
    
 | 
						|
    
 | 
						|
   scsiLunMapGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiLunMapLuIndex,  
 | 
						|
          scsiLunMapRowStatus, 
 | 
						|
          scsiAuthIntrDevOrPort, 
 | 
						|
          scsiAuthIntrName, 
 | 
						|
          scsiAuthIntrLunMapIndex, 
 | 
						|
          scsiAuthIntrLastCreation, 
 | 
						|
          scsiAuthIntrRowStatus  
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION          
 | 
						|
          "This group is a collection of attributes regarding the 
 | 
						|
          mapping between logical unit number, logical unit and target 
 | 
						|
          device." 
 | 
						|
     ::= { scsiGroups 5} 
 | 
						|
    
 | 
						|
   scsiTargetStatsGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiTgtPortInCommands, 
 | 
						|
          scsiTgtPortWrittenMegaBytes, 
 | 
						|
          scsiTgtPortReadMegaBytes, 
 | 
						|
          scsiLuInCommands, 
 | 
						|
          scsiLuReadMegaBytes, 
 | 
						|
          scsiLuWrittenMegaBytes, 
 | 
						|
          scsiLuInResets, 
 | 
						|
          scsiLuOutQueueFullStatus 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION          
 | 
						|
 
 | 
						|
          "This group is a collection of statistics for all 
 | 
						|
          implementations of the SCSI MIB that contain targets." 
 | 
						|
     ::= { scsiGroups 6} 
 | 
						|
    
 | 
						|
   scsiTargetHSStatsGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiTgtPortHSInCommands, 
 | 
						|
          scsiLuHSInCommands 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION          
 | 
						|
          "This group is a collection of high speed statistics for all 
 | 
						|
          implementations of the SCSI MIB that contain targets." 
 | 
						|
     ::= { scsiGroups 7} 
 | 
						|
    
 | 
						|
   scsiLunMapStatsGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiAuthIntrAttachedTimes, 
 | 
						|
          scsiAuthIntrOutCommands, 
 | 
						|
          scsiAuthIntrReadMegaBytes, 
 | 
						|
          scsiAuthIntrWrittenMegaBytes 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION          
 | 
						|
          "This group is a collection of statistics regarding 
 | 
						|
          initiators authorized to attach local logical unit and target 
 | 
						|
          device." 
 | 
						|
     ::= { scsiGroups 8} 
 | 
						|
    
 | 
						|
   scsiLunMapHSStatsGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiAuthIntrHSOutCommands   
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION          
 | 
						|
          "This group is a collection of high speed statistics 
 | 
						|
          regarding initiators authorized to attach local logical unit 
 | 
						|
          and target device." 
 | 
						|
     ::= { scsiGroups 9} 
 | 
						|
    
 | 
						|
   scsiInitiatorStatsGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiIntrDevOutResets,  
 | 
						|
          scsiIntrPrtOutCommands, 
 | 
						|
          scsiIntrPrtWrittenMegaBytes, 
 | 
						|
          scsiIntrPrtReadMegaBytes 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION          
 | 
						|
          "This group is a collection of statistics for all 
 | 
						|
          implementations of the SCSI MIB that contain initiators." 
 | 
						|
     ::= { scsiGroups 10} 
 | 
						|
    
 | 
						|
 
 | 
						|
   scsiInitiatorHSStatsGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiIntrPrtHSOutCommands 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION          
 | 
						|
          "This group is a collection of high speed statistics for all 
 | 
						|
          implementations of the SCSI MIB that contain initiators." 
 | 
						|
     ::= { scsiGroups 11} 
 | 
						|
    
 | 
						|
   scsiDiscoveryStatsGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiDscTgtInCommands, 
 | 
						|
          scsiDscTgtReadMegaBytes, 
 | 
						|
          scsiDscTgtWrittenMegaBytes  
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION          
 | 
						|
          "This group is a collection of statistics for all 
 | 
						|
          implementations of the SCSI MIB that contain discovered 
 | 
						|
          initiators." 
 | 
						|
     ::= { scsiGroups 12} 
 | 
						|
    
 | 
						|
   scsiDiscoveryHSStatsGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiDscTgtHSInCommands 
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION          
 | 
						|
       "This group is a collection of high speed statistics for all 
 | 
						|
       implementations of the SCSI MIB that contain discovered 
 | 
						|
       initiators." 
 | 
						|
     ::= { scsiGroups 13} 
 | 
						|
    
 | 
						|
   scsiDeviceStatGroup OBJECT-GROUP 
 | 
						|
     OBJECTS { 
 | 
						|
          scsiDeviceResets,  
 | 
						|
          scsiPortBusyStatuses  
 | 
						|
     } 
 | 
						|
     STATUS current 
 | 
						|
     DESCRIPTION 
 | 
						|
          "A collection of statistics regarding about SCSI devices and 
 | 
						|
          ports." 
 | 
						|
     ::= { scsiGroups 14 } 
 | 
						|
    
 | 
						|
   END 
 | 
						|
    
 |