Config guide for 7.3 for EDT-ACSLS.

I.    Supported OS levels:
      
      AIX               5.2.0.2 & higher Maintenance package 2
      Solaris		2.7 & higher
      HP-UX		11.11 & higher Required patch: PHSS_30049
      LINUX		Red Hat Advanced Server, Enterprise Server 3.0
			SuSE Enterprise Server 8
      WIN		2000, 2003
	    

II.   Installation
      (EDT version level represented by XXXX)

      Note: If reinstall, same or newer version, there is no need to first
      deinstall, simply install over the existing version. 

      AIX:
	    installp -FXacd ./GESedt-acsls.XXXX.aix.inst-image all

      Solaris:
	    pkgadd -a none -d ./GESedt-acsls.XXXX.sol.inst-image GESedtac

      HP-UX:
	    swinstall -s /tmp/GESedt-acsls.XXXX.hpux.depot edt-acsls

      Linux:
            rpm -vv --force -i GESedt-acsls.XXXX.rhlinux.rpm
	    rpm -vv --force -i GESedt-acsls.XXXX.suselinux.rpm

      Win 2000, 2003:
	    Click on image to execute install wizard.
	    You have a choice to change the default install directory and
	    whether to install, remove, or modify the installation.

    - Installation directory is:

      Solaris           /opt/GESedt-acsls
      AIX		/usr/lpp/GESedt-acsls
      HP-UX		/opt/GESedt-acsls
      LINUX		/opt/GESedt-acsls
      WIN		[C-Z]:\Program Files\GES\EDT-ACSLS
     
    - Two subdirectories, util, bin.
    - Directory util features utilities that carry out the same function as 
      ACSLS cmd_proc.  Syntax for each utility is shown by typing in utility
      name and hitting enter.
    - Directory bin contains the external library executable elmdt,
      and assorted supporting executables.


III.  EDT Configuration File

    - In the bin directory, move elm.conf.smp to elm.conf
      In Windows, copy sample_elmconf.txt to elmconf.txt
    - This file, contains an example of configuration contained
      in a "library description", that is a set of configuration parms
      enclosed at the top by the stanza LIBRARY and at the bottom by the
      key phrase END.
    - The utility elm_testlibdesc is used to confirm that the format of
      a library description is correct and can validate the license key
      found within a library description.
      syntax: elm_testlibdesc -l libname
    - We have a configuration GUI that allows the user to avoid having
      to do configuration directly in elm.conf, EDT Control Center.


IV.   Library Control Path Verification

      Note: For more information on the SSI API detailing optional behavior
      and multiple SSI APIs, refer to EDT SSIAPI.

      Unix:

    - Within the rc.edt file, find the line:
      
	    MEDIA_MNGR_HOST="hostname"

    - Replace "hostname" with the hostname or IP address of the ACSLS server
      you wish to use.  Note that you are safer using the IP address, as using
      a hostname means that a DNS server or hosts table will be called to
      resolve the hostname.  If you use hostname, from the command, line 
      run "ping hostname" (replacing hostname with actual hostname of machine
      you are trying to contact, the ACSLS server in this case).  If ping is
      successful, you should have no problem with using the hostname in the
      rc.edt script.  Otherwise, use the IP address. 

    - Save and close the rc.edt file.

    - Start the api
      
	    rc.edt api

      You will see the response:

	    Check mini_el and ssi ...
	    starting mini_el.
	    Sending output to nohup.out

	    starting ssi daemon... 
	    CSI_HOSTNAME:           delta	
	    Socket address:         40004
	    CSI_RETRY_TRIES:        2
	    CSI_RETRY_TIMEOUT:      4
	    CSI_TCP_RPCSERVICE:     TRUE
	    CSI_UDP_RPCSERVICE:     FALSE
	    SSI_HOSTNAME:           not used
	    SSI_INET_PORT:          not used
	    CSI_HOSTPORT:           not used
	    SIGHUP received 
	    Parent Process ID is: 19368 
	    SIGHUP received 
	    Parent Process #19368 EXITING NORMALLY
	    ssi for host delta on socket 40004 started.

    - Do the command ps -ef | grep SSI
      Expectation:  You should see an ssi process and a mini_el process, but
      no t_parent process.

    - Look in /tmp for the file event.log.  This is the log file for the SSI
      API.  Open the file and you will see two time stamped messages
      indicating:  Initiation Started and Initiation Completed.


    Windows:
    
    - Use the SSI API configuration utility, edtcu to configure the SSI API
      and start the appropriate daemons, ssi, mini_el, and if necessary
      portmapper. 


    - Prove connection to the library, by doing querying the server.

	    acsls_qserver -r -v

    - Expect to see confirmation of the connection to the library.

      Query Server:
	    Free Cells      349
	    State           STATE_RUN
	    AUDIT           current         0                       
	    AUDIT           pending         0                       
	    MOUNT           current         0                       
	    MOUNT           pending         0                       
	    DISMOUNT        current         0                       
	    DISMOUNT        pending         0                       
	    ENTER           current         0                       
	    ENTER           pending         0                       
	    EJECT           current         0                       
	    EJECT           pending         0                       

	    Server Query SUCCESS: connection to media manager confirmed.



V.    Map Library DriveIDs to System Device Files

      EDT requires that you configure a device map, to do so you run the
      following utility:

      Use elm_match_device, to obtain a match between the ACSLS driveIDs and
      the corresponding device handles configured on your system. 

      *NOTE: Make sure the communication path to ACSLS has been established as
       the utility queries ACSLS.
      *NOTE: Try to run the utility when there is little or no traffic on the
       drives.  The utility does seek to access tape devices using the no
       rewind, no repos on close device extension, but caution always needs
       to be taken on a drive that is occupied and being held in a specific
       tape position, ready for next access.

      Syntax:  
      elm_match_device -d driver [-f device#] [-g end device#] 
		       [-o num_opens] [-i timeout] [-n] [-Z] [-v] 

         driver:  all,tsm,atape,ibmtape,system 
         device#: device file devno
         combine -f and -g to start at device# and end at 2nd device#

         -o num_opens: opens to perform on a device(default 1).
         -i timeout: in secs, device ready timeout (default 120 secs).
         -n: suppress headers. 
	 -Z: show all.  Drive vendor and productID
         -v: verbose. Diag and Msgs printed to stderr. 
 
      By default elm_match_device seeks to match all tape device handles
      configured on the host.  EDT restricts itself to accessing the no rewind
      on close and no reposition on close device extension for each of the
      available major device nos.  For example under OS AIX:

      elm_match_device -d all -Z

      device     vendor    product        serial number   drive match     

      /dev/rmt0  IBM       ULTRIUM-TD1    6811061457      0,0,0,0         
      /dev/mt0                                            error 19        
      /dev/mt1   STK       9840           331000022842    0,0,0,1         
      /dev/mt2   STK       T9940A         456000003296    0,0,0,6         
      /dev/mt3   STK       9840           331000051873    0,0,0,4         
      /dev/mt4   STK       T9940A         456000003723    0,0,0,5         

      Notice how the error is reported if contact with the drive can not be
      made.

      Through options, you can adjust drive parameters for open timeout and
      number of open attempts.  You can restrict the search based on the type
      of driver under which a devices are configured, you can restrict to a
      range of device numbers or a specific device number, and you can combine
      the driver restriction with the range or specific device number search.

      *NOTE*
      If elm_match_device ever gums up on an open, then you are hitting
      severely stale device handles.  The SAN was reconfigured.
      Get rod of the stale handles, or restrict match device using driver
      type and/or device number range.


VI.   Confirm Data I/O integrity

      Elm_label imitates the autolabel function of EDT.  But in the
      configuration it accomplishes two tasks:

    - It truly confirms the driveID to device file match in that if you are
      using a volume that has an accurate internal label, you match what the
      media manager mounts on the drive with what is being read via the
      device.

    - If the SAN is not configured correctly, you may have been able to open
      the device but can do no device I/0.  In this case, 99% of the time
      rebooting the SAN gateway takes care of the problem.


    - Syntax  
            elm_label -d driveID -f device -n vol [-i timeout] 
		      [-X] [-v] 

            driveID: media manager drive identifier 
		     example - 0,0,2,0 
	    device: in form
	    AIX             /dev/rmt# or /dev/mt# 
	    Solaris         /dev/rmt/#cb, /dev/rmt/#mt, /dev/rmt/#st 
	    HP-UX           /dev/rmt/#m or /dev/rmt/tsmmt#
	    Windows         \\.\Tape# or \\.\mtx.y.z.n
                            Tape# or mtx.y.z.n
	    Linux            /dev/tsmscsi/mt# or /dev/IBMtape#
	    vol: 6 to 7 char barcode label

            Optional:
	    -i timeout: in secs, device ready timeout (default 120).
	    -v: verbose. Diag and Msgs printed to stderr. 
	    -X: extended label, VOL1,HDR1,HDR2,FM vs default VOL1,FM
		Needed to work around prob with dev class DLT, ECART.


    - Example:

      elm_label -d 0,0,0,1 -f /dev/mt1 -n ISV009 -i 60 -v 2>>diag.log

      [1]: ISV009
                 Mount...Success
                 Label...Success
                 Unload...Success
                 Dismount...Success

      Place a tail on the diag log and see the details of the drive opening
      and confirming the label.



VII.  Basic EDT-ACSLS Configuration:

      The sample elm.conf shows basic configuration for the ACSLS library.
      The file contains one or more library descriptions, each starting with
      the entry LIBRARY and ending with the entry END.

      LIBRARY <libname>
      - The libname must be twenty or less characters and can not contain the
	character "."
      - It must match (case sensative) the external libname configured to TSM.
        Look the end section for basic TSM configuration and examples.

            Example:  LIBRARY TSM1

      LIBTYPE ACSLS
      This entry must follow immediately after the LIBRARY entry.

      LICENSE TEMP <key>
      The license line can appear anywhere within a library
      description, or can be placed at the top of the file, outside
      of the library descriptions. Temporary keys are supplied by Gresham
      Enterprise Storage.
      
            Example:  LICENSE TEMP 1234567890

      LICENSE PERM <key>
      A permanent license depends on the machine serial number, and on the 
      LIBTYPE.  To obtain a permanent key for a machine, run the utility,
      elm_find_machineID (there are no command line options), with this number
      and the libtype, GES support can generate a permanent key.

            Example: LICENSE PERM 1087654231

      POOL <poolid>
      In order to access scratch volumes, EDT requires a scratch pool
      identifier as defined to ACSLS.

            Example:  POOL 100

      In a mixed media environment, where you would have separate library
      descriptions, it is suggested that a scratch pool be defined in ACSLS
      for each media type present in the library.  In EDT, name the pool
      that will contain volumes that are compatible with the drives that you
      list in the library description.

      In an environment with multiple TSM Servers you may wish to have 
      separate pool(s) for each server.  You can however, stay with a basic
      set of pools each representing a media type, and have all servers
      drawing scratch from that pool.

      CLIENTID <clientname>
      When EDT gains access to a drive it is locked via the ACSLS drive lock
      mechanism.  EDT takes advantage of the ability to uniquely name the
      userid associated with the drive lock.  If querying ACSLS for drive
      locks, a drive in use by EDT has the form:  clientname.libname.PID

      The client name by default is the machine hostname.  The libname
      matches library description libname.  The PID matches the process id of
      the elmdt process controlling the mount request.

      You may wish to override the hostname due to length.  The overall userid
      for drive locks must be no greater than 64 characters, and hostnames
      by definition can be upwards of 256 characters. 

      DRIVE <device handle> ACS_<driveID>
      Drive entries contain both a device file and a library drive
      identifier preceded by the prefix "ACS_".

    - The device file must be matched to the physical drive.
      Use the drive map you created with elm_match_device utility.

            Example:
	    DRIVE /dev/mt0 ACS_0,0,0,1
	    DRIVE /dev/mt1 ACS_0,0,0,3

    - Create a DRIVE entry for each drive to which you need access.
      It is possible to have more than one adaptor connected to the drives via
      the SAN, making for high availability data I/0 path. For example, a
      drive is made accessible through two device handles and is configured in
      EDT as separate entries.

            Example:
	    DRIVE /dev/mt0 ACS_0,0,0,1
	    DRIVE /dev/mt7 ACS_0,0,0,1

    - If configuring for multiple drive types, keep drives of like type
      configured in one library description.  This is in keeping with TSM
      grouping of like drives being controlled by a device class of a specific
      drive type, and that particular device class being associated with a
      singular library definition.



VIII. Options.

    - SSI API Overrides

      For the following options, refer to EDT SSIAPI.

      ACSLS <hostname> <socket #>
      SSI_HOSTNAME <hostname or ip address>
      SSITIMEOUT


    - Communications Try and Retry
    
      DONT_ESTABLISH_COMM
      Ahead of each task asked by TSM to be accomplished, mount, dismount,
      eject volume, query volume status, and release volume to scratch, EDT
      establishes contact with ACSLS using a query server request. If a
      communications failure is detected, EDT retries the query up till a user
      set timeout period.  The timeout is associated with the mountwait period
      defined to the TSM device class.  Refer to the TSM config example for
      more detail.  This entry turns off the query server and retry mechanism.
      

      COMM_CHECK_TIMEOUT <time in minutes>
      In the event of a failure for any request sent to ACSLS, this entry
      enables a communication check and retry mechanism.  If the error is
      judged to be communication failure related, EDT switches to query server
      mode in order to reaffirm that the ACSLS server can be contacted and is
      in a state able to accept requests.  If communication can not be
      established, the queries are retried up till the prescribed timeout
      period set with this entry.  If communication is reestablished, the
      failed request is retried.  

             Example: COMM_CHECK_TIMEOUT 15 

    - Drive clearing behavior.

      CLEAR_DRIVES_START
      When TSM initializes, check the drives for any orphaned volumes left in
      drives from when TSM or TSM host was last active.


    - Drive Selection
       
      RANDOMIZE_DRIVE_SELECTION
      If you wish to spread wear evenly across the drives, turn on
      randomized drive selection. 


      PREFERRED_DRIVE_NUMBER #
      With randomization, you are giving equal weight to each drive.
      You may wish however to have a set of drives chosen ahead of others.
      Replace # with the number of drives in the subset.  As the drives are
      listed in your configuration, the first # drives are randomized for
      selection choice, then the remaining drives are randomized for selection.


      CLOSE_LSM_DRIVE_SELECTION
      If your highest priority is minimizing movement between LSM's
      use this drive selection policy.  It dictates that you give priority to
      the drives in the LSM where the volume currently resides, and if the
      drives in that lsm are busy choose the next closest lsm.

      By default The physical layout of the lsms is assumed to be a chain
      with beginning and ending points and vol pass through ports between
      lsms.  For example, a system with three LSMs, 0-1-2.  With this policy,
      a volume found in LSM 0 would place preference on drives in the order
      0,1,2, whereas a volume in LSM 2 would place preference in the reverse
      order, 2,1,0.

      Combine CLOSE_LSM_DRIVE_SELECTION with RANDOMIZE_DRIVE_SELECTION.  
      The close lsm pattern holds, and the drives within each lsm are
      randomized.

      Combine CLOSE_LSM_DRIVE_SELECTION with PREFERRED_DRIVE_NUMBER and
      RANDOMIZE_DRIVE_SELECTION. The close lsm pattern holds, the drives
      in each lsm are split into subsets with the preferred drives to be
      chosen ahead of the other drives in the lsm, and each subset of drives
      is randomized.


      PREFERRED_LSM_DRIVE_SELECTION #
      Instead of choosing LSM closest to the volume, you can instead give
      preference to one LSM.  Beyond this LSM, the choice of LSM follows the
      chain link layout as previously mentioned.

      Combine PREFERRED_LSM_DRIVE_SELECTION with RANDOMIZE_DRIVE_SELECTION.  
      The preferred lsm pattern holds, and the drives within each lsm are
      randomized.

      Combine PREFERRED_LSM_DRIVE_SELECTION with PREFERRED_DRIVE_NUMBER and
      RANDOMIZE_DRIVE_SELECTION. The preferred lsm pattern holds, the drives
      in each lsm are split into subsets with the preferred drives to be
      chosen ahead of the other drives in the lsm, and each subset of drives
      is randomized.
      
      When PREFERRED_DRIVE_NUMBER is combined with either of the lsm drive
      selection policies, it takes on an extended format.  The associated
      number is expanded to #,#,#...  Each place represents the preferred
      number for each lsm.

            Example:
	    PREFERRED_DRIVE_NUMBER 3,1,2

      The example says to mark 3 drives in lsm 0 preferred, 1 drive in lsm 1,
      and 2 drives in lsm 2.  Preferred drives are listed ahead of non
      preferred for each lsm in the library description.


      MAP_LSM_DRIVE_SELECTION TOTAL_N
      LSM_#,#,#,...N elements
      LSM_#,#,#,...N elements
      ...
      N LSM entries

      For any LSM layout that needs to be mapped differently from the default
      chain link layout, use MAP_LSM_DRIVE_SELECTION to describe the LSM order
      for close drive selection.  For instance a permutation of the three LSM
      example, would be an additional pass thru port between LSMs 0 and 2
      making for a circular pattern.  The map would look like the following:

            Example:
	    MAP_LSM_DRIVE_SELECTION TOTAL_3
	    LSM_0,1,2
	    LSM_1,0,2
	    LSM_2,0,1

      This example is somewhat simple and does not show the full potential of
      the mapping mechanism.  Look for a more detailed discussion and more
      examples of lsm mapping.  See LSM Map layouts.



   -  Mount Traffic Control
      
      MOUNT_WAIT_TIME SLEEP_<time in secs.>
      If all drives are in use, EDT by default will wait 10 secs, regather
      drive status, and reattempt to find a drive to use for the mount
      request.  If no drive is found, this cycle continues until a user
      defined timeout, refer to the TSM configuration example and the mount
      wait period associated with a device class.  This entry overrides the
      default wait period of 10 seconds.

            Example:  MOUNT_WAIT_TIME SLEEP_30


      MOUNT_NO_WAIT
      This option turns of the default mechanism of waiting for a free drive
      to complete the mount operation.  


      SERIALIZE_LOCKS
      This option serializes incoming mount requests from a TSM Server,
      preventing the SSI API and ACSLS from being bombarded by simultaneous
      mount requests.  Order is sorted as first come first serve, and if a
      mount is made to wait for a drive to come available, then all impending
      mount requests are made to wait.


      REFRESH_DRIVEINFO
      If two elmdt processes are servicing mount requests at the same time,
      their information on what drives are available is the same, and as a
      result may clash over who is going to get a lock on a drive.  By
      default, the process that does not get the lock, tries the next
      available drive.  If there are multiple mount requests occurring at the
      same time, this pattern of lock contention could be repeated again and
      again.  This option enables an EDT process to refresh its drive status
      information if a lock contention occurs. 


    - Reaction to Volume Condition

      In order for a volume to be eligible for mount, it must be in a home
      slot.  For the following volume status, EDT by default makes the
      following returns to TSM.

             Status		Return to TSM
          -  not in library	Volume Unavailable
	     ejected           
	  -  in transit		Wait and retry.
	  -  invalid		Volume Unknown
	  -  in drive		Cancelled
	  -  other		Cancelled


      VOL_IN_DRIVE <behavior>
      For volume already found in drive,  EDT does all it can to establish if
      it can be accessed. Barring this, the default is to cancel the mount. 

      This option allows you to change the default behavior to:
      
            UNAVAILABLE
	    Tsm marks vol as unavailable.  
	    Update TSM vol access to readwrite to be mountable.
            
	    WAIT
	    In a TSM LAN-FREE environment, where several clients can request
	    access to the same volume.  
	    To minimize this consider TSM collocation.
  
            Example: VOL_IN_DRIVE WAIT


      VOL_NOT_IN_LIBRARY <behavior>
      The default return is to return volume unavailable.
      You can change this to LIBRARY_ERROR, CANCELLED, or WAIT.
      Enable message class MENT type TOPN, or message sev level 5, or
      specifically message 350 to see tape operator notification.

	    Example:
	    <6008> EDT0350  SEV 5  03-24-2004 04:13:54
		   Insert Vol 123456 into Library 
		   acsls_m_estab_vol_status.cpp (173)

            Example: VOL_NOT_IN_LIBRARY WAIT


    - Drive Interaction

      DRIVE_OPEN_TIMEOUT <time in secs.>
      EDT does interact with the drive, doing a test open to insure that a
      drive is reachable and a label verification to insure that the media is
      sound, the write volume is in the drive, and in the case of a scratch
      volume, will autolabel the volume if required.  The default time for a
      volume to come ready is 120 seconds.  This longish wait period is to
      accommodate older drive models.  This default time is overridden with 
      this option.
            Example: DRIVE_OPEN_TIMEOUT 60


      DRIVE_DISABLE TEST_OPEN
      The test open of a drive can be stopped using this option.


      DISMOUNT_ACS FORCE
      Skip unload issued to device.  Include force flag with dismount
      command sent to ACSLS.

      DISMOUNT_ACS FORCE SLEEP_<time in secs.>
      Skip unload issued to device.  Include force flag with dismount
      command sent to ACSLS.  Sleep prior to issuing dismount.
            Example:  DISMOUNT_ACS FORCE SLEEP_10


    - Retries and Reaction

      DISMOUNT SUCCESS
      If desired, EDT will always report to TSM that a dismount was successful.


      DISMOUNT RETRY_# SLEEP_<time in secs.>
      For dismount failure, you can force retry with this option. Replace #
      with the number of retries.  Replace time in secs with a value dictating
      how long to sleep between retries.

            Example:
	    DISMOUNT RETRY_2 SLEEP_30


      DISMOUNT KEEP_DRIVE_LOCKED <error code(s)>
      By default if a drive can not be unloaded or dismounted, the drive
      remains locked.  The reason for this is to enable easy identification as
      to the host client, application, and controlling process through the
      userID associated with the lock.

      EDT features clear drive technology to insure at host reboot or restart
      of TSM, any drives previously in use are cleared.  Also in use is the
      ability to gauge if a needed volume by TSM is found in a drive and if
      can not be used is attempted to be cleared.

      Also separately available is an advanced EDT mechanism that at
      scheduled maintenance periods, seeks to clear drives left orphaned by
      drive failure, robotic failure, library failure, TSM failure, and TSM
      host failure.

      If however, problems have been seen with drives such that further 
      interaction with the drive might be  a waste of time (i.e. human 
      intervention needed) or may cause the library to go off line, specific 
      errors can be identified such that any EDT drive clear operation will
      not be attempted on the drive.

      All standard error ACSLS status codes are accepted and additionally the
      special cases: 
      
            STATUS_ALL, STATUS_BAD_DEVICE_OPEN,
	    STATUS_BUSY_DEVICE_OPEN, STATUS_BAD_DEVICE_UNLOAD,
	    STATUS_BAD_LABEL_HARDWARE, STATUS_BAD_LABEL_WRONG_VOL,
	    STATUS_BAD_LABEL_MEDIA, STATUS_BAD_LABEL_WRPROTECT
          
      You can list status codes individually or one after the other, and as
      many as you want.  You can use multiple lines for status code entries,
      as long as they have the DISMOUNT KEEP_DRIVE_LOCKED phrase in front of
      them. 

            Example:  
        DISMOUNT KEEP_DRIVE_LOCKED STATUS_BAD_DEVICE_UNLOAD
	DISMOUNT KEEP_DRIVE_LOCKED STATUS_DRIVE_OFFLINE STATUS_LABEL_HARDWARE


      MOUNT_LFR_KEEP_DRIVE_LOCKED <error code(s)>
      Same as previous, but kdl is triggered if specific errors seen on the
      mount request.  Note that if the volume does get mounted, EDT will
      attempt to access the drive for data I/0.  Once done, the volume will
      not be dismounted and the drive will be kept locked.


      MOUNT_LFR_RETRY RETRY_<number> <error code(s)>
      If a mount request fails, and EDT can not detect the volume in a drive,
      you can force retries for specific error codes or all error codes,
      in effect tuning library failure recovery for specific errors or
      turning on for all errors.  The number of retries to attempt is dictated
      by the RETRY_ option. Status codes are listed individually and as many
      as you want.  You can use multiple lines for the error code entires, 
      just preface each line with the MOUNT_LFR_RETRY phrase.  There is a 
      special code "STATUS_ALL" that will force retries on all error status 
      codes.
            Example:
	    MOUNT_LFR_RETRY RETRY_3 STATUS_ALL


      RELEASE SUCCESS
      Return success on release no matter the outcome.
      

      RELEASE SUCCESS_IMMEDIATE
      Return success without even doing actual release.


    - ACSLS command access control

      COMMAND_ACCESS_CONTROL
      If ACSLS command access control is active, EDT needs to know it.
      This way EDT will no longer use the unique userids when locking a
      drive.  Instead, EDT will send the userid as a NULL, and ACSLS will set
      the userid based on the client name entered into its internet.addresses
      file.  You can combine this with the option CLIENTID, in which case EDT
      will send this userid in with a drive lock request. 


    - Labeling Behavior

      DRIVE_DISABLE LABEL
      Label verification and auto label on scratch vols is turned off with
      this option.


      EXTENDED_LABEL
      By default EDT labels a scratch volume if needed with the standard VOL1
      80 byte volume header followed by a file mark.  If you wish to extend
      this to a full header, include this option in your library
      description. A full label includes an 80 byte VOL1 header, 80 byte HDR1
      header, 80 byte HDR2 header, followed by a filemark.  Note that if you
      have elected to disable the label verification, this option is
      invalidated.


      FORCE_LABEL
      Skip label read and if a scratch volume write label.
      Quick work around for problems encountered during a read label.
      If the condition of the volume is such that autolabel can not completely
      access the condition of the tape, no action will be taken.  If the
      condition is such and the requested volume is a scratch needing a label,
      TSM will reject the volume. This option allows a quick work around to
      force the label and get TSM to accept the volume.  While this works in
      the interim, the condition of the volume can be accessed and a more
      graceful solution can be made available.  

      For example, a tape written by a 9840C, when used as a scratch volume
      in a 9840A or 9840B and upon doing a read label, could receive an error
      that gets misidentified as a media fault or gets an error with no
      supporting sense data so auto label takes no action.  The same example
      extends to a volume written by a 9940B placed in a 9940A drive.

      For example, a volume written by a 9840A or 9840B used as a scratch
      volume in a 9840C can be read in the lower density format but data can
      not be appended to the tape. By skipping the read label, you can go
      ahead and force the label in the higher density.  The same applies for a
      9940B drive with a volume written by the lower density 9940A.


      WRONGVOL_FORCE_LABEL
      If the internal label does not match the barcode, EDT rejects the
      volume.  However, if you are in a situation where you know you have a
      great deal of previously used volumes to use as scratch and they have
      new barcode labels, this option will force the internal label to be
      rewritten to match the barcode label.  


      LABEL_RECOVERY <operation> <default behavior> <override behavior>
      The auto label procedure also provides a means of examining error while
      accessing the drive, reading the media, and in the case of a scratch
      volume that needs a label, writing to the media.  Based on the error,
      EDT takes the following corrective action:

      OPEN ERR:		Error occurred on drive open.  Dismount the volume, 
			if scratch mount request return volume to pool,
			return LIBRARY_ERROR to TSM.  The result is that TSM
			tries upwards of 3 additional times to get the volume
			mounted.
      DRIVE_ERR:	Error indicates hardware failure, same as OPEN_ERROR.
      WRONG_VOL_ERR:	Label mismatch.  Internal label does not match
			barcode. Error is treated the same as open error and
			drive error.  It could be possible that some one
			replaced the barcode labels on a set of volumes that
			already had internal labels.
      MEDIA ERR:	Dismount the volume, return VOLUME_UNAVAILABLE for
			private mount request, return LIBRARY_ERROR for
			scratch mount request.  TSM on the private volumes
			will mark the volumes as unavailable, and on the
			scratch mount requests will again request the mount
			of a scratch volume or cancel, depending on the TSM
			process requesting volume mount(s).
      WRPROTECT_ERR:	A mount request was made, readwrite access, and the
			volume was found to be write protect enabled.
			treated like MEDIA_ERROR.


      LABEL_RECOVERY allows you to override default recovery behavior,
      by allowing you to change one type of behavior into another.
      Use the following entry to change default behavior:


      LABEL_RECOVERY <operation> <default behavior>  <override behavior>

      where 
      Operation is OPEN, READ, or WRITE.
      Default behavior is any of the above listed behaviors.
      Override behavior is any of the above listed behaviors and in addition:

      FORCE_LABEL:	Error occurred on read, but force the labeling.
      SAFE_ERR:		Dismount vol, do not return any scratch vol to a pool,
			return LIBRARY_ERR to TSM, insuring no vol is marked
			unavailable, and upwards of 3 retries are attempted.
      STOP_ERR:		Dismount vol, do not return any vol to a scratch pool,
			return VOLUME_UNAVAILABLE to TSM, insuring that
			process is stopped. Private vol is marked as
			unavailable.

      Example:
      A volume error condition  is causing DRIVE_ERR on the read.  In this
      case the volume if a scratch mount request is placed back into the
      scratch pool, where it could continue to create havoc.  Upon seeing
      this error occur, you could easily switch the behavior to MEDIA_FAULT 
      insuring that the vol is not returned to scratch status.  You could
      think of this as a work around until it can be found out why a volume
      would cause a drive to return sense code hardware failure for what is
      clearly being caused by a errant volume.

      LABEL_RECOVERY READ DRIVE_ERR MEDIA_ERR


      LABEL_RECOVERY <operation> ERR_<error code> <recovery behavior>
      Similar to previous LABEL_RECOVERY, but specific errors can be targeted.
      The use of sense data from the tape device allows for detailed knowledge
      of the condition of the tape is labeling is needed and for helping judge
      the error recovery.  Occasionally, however error occurs on read or write
      of a label, in which no valid sense data is shown, leaving only the
      return error upon which to judge the recovery behavior.  This is not a
      reliable method, as in the majority of cases you receive the catch all
      uninformative EIO, or I/O error.  Rather than take the incorrect action,
      EDT by default passes the responsibility to TSM, which might not take
      the best course of action, i.e. putting an errant volume back into
      a scratch pool, where it can again cause havoc on a scratch mount
      request.  For example on read, a volume returns ENXIO or errno 6 and no
      valid sense data.  TSM dismounts the tape, returns it to scratch, calls
      for mount scratch and again gets the same volume.  Upon seeing this
      behavior and diagnosing the error through EDT diagnostics, you could use
      the following form of LABEL_RECOVERY to change EDT behavior to recognize
      the error code and take appropriate recovery action.

      Operation is OPEN, READ, or WRITE.
      Error code:
      - Errno by replacing error code.
      - Use the special errno symbol * to indicate acceptance of any error.
      - You can list multiple errnos by using separate entries.
      - Use any of the override behaviors 
      Recovery behavior is any of the override behaviors listed in first
      explanation of LABEL_RECOVERY.

      Example:
      You want to get errno 6 recognized as an error that will cause the 
      volume to be dismounted, not returned to the scratch pool, and return a 
      code that will cause TSM to request the mount for a scratch volume again
      or get it to recognize that a private volume needs to be marked as 
      unavailable.

      LABEL_RECOVERY READ ERR_6 MEDIA_ERR

      NOTE:
      The methods of changing recovery behavior and targeting specific
      errnos to activate a recovery method can be used together.  Whichever
      method is listed first takes precedence over the other.  Per the
      examples, if you had an error that gave you errno 6 and sense data
      indicating hardware failure, the recovery behavior would be determined
      by the first encountered entry.


    - Diagnostics

      DIAG <diag class(es)> <log file>
      Diagnostics can be turned on and redirected to a file of your
      choice. There are a number of diagnostic classes that begin with the key
      letter "E", and the last entry in the line is the path and file name.
      EDRV - drive ioctls.
      ELBL - autolabel functionality.
      ESUB - functional call level to media manger.
      EMEM - memory calls.
      ELCK - serialization locks.
      EPRC - process identification.
      ECNV - conversions and config file access.
      EENT - libtype specific entry level.
      EELM - elm level.

      Enabling all classes produces a lot of debug.  A good overview of the
      action can be obtained by enabling ECNV EENT EELM ELBL EDRV

      Example: DIAG ECNV EENT EELM ELBL EDRV /usr/lpp/GESedt-acsls/bin/diag.log


IV:   Testing the configuration:
      Run the utility elm_testlibdesc against your library description.
      It will tell you if there is any problem with the format.
      If you see completion with a warning or error, run the program in verbose
      mode to see details.

      example: elm_testlibdesc -l LIB1
	       elm_testlibdesc -l LIB1 -v


X.   TSM configuration

     Refer to guide, "EDT TSM Interaction".