scsi.c

通用SCSI设备备份/读写程序

/* SCSI.C - VMS-specific SCSI routines.
**
** TECSys Development, Inc., April 1998
**
** This module began life as a program called CDWRITE20, a CD-R control
** program for VMS. No real functionality from the original CDWRITE20
** is present in this module, but in the interest of making certain that
** proper credit is given where it may be due, the copyrights and inclusions
** from the CDWRITE20 program are included below.
**
** The portions of coding in this module ascribable to TECSys Development
** are hereby also released under the terms and conditions of version 2
** of the GNU General Public License as described below....
*/

/* The remainder of these credits are included directly from the CDWRITE20
** sources. */

/* Copyright 1994 Yggdrasil Computing, Inc. */
/* Written by Adam J. Richter ([e-mail]) */

/* Rewritten February 1997 by Eberhard Heuser-Hofmann*/
/* using the OpenVMS generic scsi-interface */
/* see the README-file, how to setup your machine */

/*
**  Modified March 1997 by John Vottero to use overlapped, async I/O
**  and lots of buffers to help prevent buffer underruns.
**  Also improved error reporting.
*/

/* This file may be copied under the terms and conditions of version 2
   of the GNU General Public License, as published by the Free
   Software Foundation (Cambridge, Massachusetts).

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* The second notice comes from sys$examples:gktest.c (OpenVMS 7.0)*/

/*
** COPYRIGHT (c) 1993 BY
** DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASSACHUSETTS.
** ALL RIGHTS RESERVED.
**
** THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
** ONLY  IN  ACCORDANCE  OF  THE  TERMS  OF  SUCH  LICENSE  AND WITH THE
** INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR  ANY  OTHER
** COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
** OTHER PERSON.  NO TITLE TO AND  OWNERSHIP OF THE  SOFTWARE IS  HEREBY
** TRANSFERRED.
**
** THE INFORMATION IN THIS SOFTWARE IS	SUBJECT TO CHANGE WITHOUT NOTICE
** AND	SHOULD	NOT  BE  CONSTRUED  AS A COMMITMENT BY DIGITAL EQUIPMENT
** CORPORATION.
**
** DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE  OR  RELIABILITY OF ITS
** SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
*/

/*
  Define the Generic SCSI Command Descriptor.
*/

typedef struct scsi$desc
{
  unsigned int SCSI$L_OPCODE;	    /* SCSI Operation Code */
  unsigned int SCSI$L_FLAGS;	    /* SCSI Flags Bit Map */
  unsigned char *SCSI$A_CMD_ADDR;   /* ->SCSI Command Buffer */
  unsigned int SCSI$L_CMD_LEN;	    /* SCSI Command Length (bytes) */
  unsigned char *SCSI$A_DATA_ADDR;  /* ->SCSI Data Buffer */
  unsigned int SCSI$L_DATA_LEN;	    /* SCSI Data Length (bytes) */
  unsigned int SCSI$L_PAD_LEN;	    /* SCSI Pad Length (bytes) */
  unsigned int SCSI$L_PH_CH_TMOUT;  /* SCSI Phase Change Timeout (seconds) */
  unsigned int SCSI$L_DISCON_TMOUT; /* SCSI Disconnect Timeout (seconds) */
  unsigned int SCSI$L_RES_1;	    /* Reserved */
  unsigned int SCSI$L_RES_2;	    /* Reserved */
  unsigned int SCSI$L_RES_3;	    /* Reserved */
  unsigned int SCSI$L_RES_4;	    /* Reserved */
  unsigned int SCSI$L_RES_5;	    /* Reserved */
  unsigned int SCSI$L_RES_6;	    /* Reserved */
}
SCSI$DESC;


/*
  Define the SCSI Input/Output Status Block.
*/

typedef struct scsi$iosb
{
  unsigned short SCSI$W_VMS_STAT;   /* VMS Status Code */
  unsigned long SCSI$L_IOSB_TFR_CNT; /* Actual Byte Count Transferred */
  unsigned char SCSI$B_IOSB_FILL_1; /* Unused */
  unsigned char SCSI$B_IOSB_STS;    /* SCSI Device Status */
}
SCSI$IOSB;


/*
  Define the VMS symbolic representation for a successful SCSI command.
*/

#define SCSI$K_GOOD		0


/*
  Define the SCSI Flag Field Constants.
*/

#define SCSI$K_WRITE        	0x0 /* Data Transfer Direction: Write */
#define SCSI$K_READ         	0x1 /* Data Transfer Direction: Read */
#define SCSI$K_FL_ENAB_DIS  	0x2 /* Enable Disconnect/Reconnect */


/*
  Define DESCR_CNT.  It must be a power of two and large enough
  for the maximum concurrent usage of descriptors.
*/

#define DESCR_CNT 16


#define MK_EFN			0   /* Event Flag Number */
#define FailureStatusP(Status)	(~(Status) & 1)


static struct dsc$descriptor_s *descr(char *String)
{
  static struct dsc$descriptor_s d_descrtbl[DESCR_CNT];
  static unsigned short descridx = 0;
  struct dsc$descriptor_s *d_ret = &d_descrtbl[descridx];
  descridx = (descridx + 1) & (DESCR_CNT - 1);
  d_ret->dsc$w_length = strlen((const char *) String);
  d_ret->dsc$a_pointer = String;
  d_ret->dsc$b_class = 0;
  d_ret->dsc$b_dtype = 0;
  return d_ret;
}


static int SCSI_OpenDevice(char *DeviceName)
{
  unsigned long d_dev[2], iosb[2], Status;
  union prvdef setprivs, newprivs;
  unsigned long ismnt = 0;
  unsigned long dvcls = 0;
  unsigned long dchr2 = 0;
  int DeviceFD = 0;
  struct itmlst_3 {
    unsigned short ilen;
    unsigned short code;
    unsigned long *returnP;
    unsigned long ignored;
  } dvi_itmlst[] = { { 4, DVI$_MNT, 0 /*&ismnt*/, 0 },
		     { 4, DVI$_DEVCLASS, 0 /*&dvcls*/, 0 },
		     { 4, DVI$_DEVCHAR2, 0 /*&dchr2*/, 0 },
		     { 0, 0, 0, 0 } };
  dvi_itmlst[0].returnP = &ismnt;
  dvi_itmlst[1].returnP = &dvcls;
  dvi_itmlst[2].returnP = &dchr2;
  Status = sys$alloc(descr(DeviceName), 0, 0, 0, 0);
  if (FailureStatusP(Status))
    {
      VMS_ExitCode = Status;
      FatalError("cannot allocate device '%s' - %X\n", DeviceName, Status);
    }
  Status = sys$assign(descr(DeviceName), &DeviceFD, 0, 0);
  if (FailureStatusP(Status))
    {
      VMS_ExitCode = Status;
      FatalError("cannot open device '%s' - %X\n", DeviceName, Status);
    }
  Status = sys$getdviw(0, DeviceFD, 0, &dvi_itmlst, &iosb, 0, 0, 0);
  if (FailureStatusP(Status))
    {
      VMS_ExitCode = Status;
      FatalError("cannot $getdvi(1) on device '%s' - %X\n", DeviceName, Status);
    }
  if (FailureStatusP(Status = iosb[0]))
    {
      VMS_ExitCode = Status;
      FatalError("cannot $getdvi(2) on device '%s' - %X\n", DeviceName, Status);
    }
  if (dvcls != DC$_TAPE)
    {
      VMS_ExitCode = SS$_IVDEVNAM;
      FatalError("specified device is NOT a magtape: operation denied\n");
    }
#ifndef __DECC
#ifndef DEV$M_SCSI
#define DEV$M_SCSI 0x1000000
#endif
#endif
  if (~dchr2 & DEV$M_SCSI)
    {
      VMS_ExitCode = SS$_IVDEVNAM;
      FatalError("specified magtape is NOT a SCSI device: operation denied\n");
    }
#if USING_DEC_DRIVE | USING_LDRSET
#ifndef __DECC
#ifndef DEV$M_LDR
#define DEV$M_LDR 0x100000
#endif
#endif
  if (~dchr2 & DEV$M_LDR)
    {
      VMS_ExitCode = SS$_IVDEVNAM;
      FatalError(
	"specified SCSI magtape does not have a loader: operation denied\n");
    }
#endif
  if (ismnt)
    {
      VMS_ExitCode = SS$_DEVMOUNT;
      FatalError("specified device is mounted: operation denied\n");
    }
  ots$move5(0, 0, 0, sizeof(newprivs), &newprivs);
  newprivs.prv$v_diagnose = 1;
  newprivs.prv$v_log_io = 1;
  newprivs.prv$v_phy_io = 1;
  Status = sys$setprv(1, &newprivs, 0, 0);
  if (FailureStatusP(Status))
    {
      VMS_ExitCode = Status;
      FatalError(
	"error enabling privs (diagnose,log_io,phy_io): operation denied\n");
    }
  Status = sys$setprv(1, 0, 0, &setprivs);
  if (FailureStatusP(Status))
    {
      VMS_ExitCode = Status;
      FatalError("error retrieving current privs: operation denied\n");
    }
  if (!setprivs.prv$v_diagnose)
    {
      VMS_ExitCode = SS$_NODIAGNOSE;
      FatalError("DIAGNOSE privilege is required: operation denied\n");
    }
  if (!setprivs.prv$v_phy_io && !setprivs.prv$v_log_io)
    {
      VMS_ExitCode = SS$_NOPHY_IO;
      FatalError("PHY_IO or LOG_IO privilege is required: operation denied\n");
    }
  return DeviceFD;
}


static void SCSI_CloseDevice(char *DeviceName,
			     int DeviceFD)
{
  unsigned long Status;
  Status = sys$dassgn(DeviceFD);
  if (FailureStatusP(Status))
    FatalError("cannot close SCSI device '%s' - %X\n", DeviceName, Status);
}


static int SCSI_ExecuteCommand(int DeviceFD,
			       Direction_T Direction,
			       CDB_T *CDB,
			       int CDB_Length,
			       void *DataBuffer,
			       int DataBufferLength,
			       RequestSense_T *RequestSense)
{
  SCSI$DESC cmd_desc;
  SCSI$IOSB cmd_iosb;
  unsigned long Status;
  int Result;
  memset(RequestSense, 0, sizeof(RequestSense_T));
  /* Issue the QIO to send the SCSI Command. */
  ots$move5(0, 0, 0, sizeof(cmd_desc), &cmd_desc);
  cmd_desc.SCSI$L_OPCODE = 1; /* Only defined SCSI opcode... a VMS thing */
  cmd_desc.SCSI$A_CMD_ADDR = CDB;
  cmd_desc.SCSI$L_CMD_LEN = CDB_Length;
  cmd_desc.SCSI$A_DATA_ADDR = DataBuffer;
  cmd_desc.SCSI$L_DATA_LEN = DataBufferLength;
  cmd_desc.SCSI$L_PAD_LEN = 0;
  cmd_desc.SCSI$L_PH_CH_TMOUT = 180; /* SCSI Phase Change Timeout (seconds) */
  cmd_desc.SCSI$L_DISCON_TMOUT = 180; /* SCSI Disconnect Timeout (seconds) */
  switch (Direction)
    {
      /*
	NOTE: Do NOT include flag SCSI$K_FL_ENAB_SYNC.
	      It does NOT work for this case.
      */
    case Input:
      cmd_desc.SCSI$L_FLAGS = SCSI$K_READ | SCSI$K_FL_ENAB_DIS;
      break;
    case Output:
      cmd_desc.SCSI$L_FLAGS = SCSI$K_WRITE | SCSI$K_FL_ENAB_DIS;
      break;
    }
  /* Issue the SCSI Command. */
  Status = sys$qiow(MK_EFN, DeviceFD, IO$_DIAGNOSE, &cmd_iosb, 0, 0,
                    &cmd_desc, sizeof(cmd_desc), 0, 0, 0, 0);
  Result = SCSI$K_GOOD;
  if (Status & 1)
    Status = cmd_iosb.SCSI$W_VMS_STAT;
  if (Status & 1)
    Result = cmd_iosb.SCSI$B_IOSB_STS;
  if (Result != SCSI$K_GOOD)
    {
      unsigned char RequestSenseCDB[6] =
	{ 0x03 /* REQUEST_SENSE */, 0, 0, 0, sizeof(RequestSense_T), 0 };
      printf("SCSI command error: %d - requesting sense data\n", Result);
      /* Execute Request Sense to determine the failure reason. */
      ots$move5(0, 0, 0, sizeof(cmd_desc), &cmd_desc);
      cmd_desc.SCSI$L_OPCODE = 1; /* Only defined SCSI opcode... a VMS thing */
      cmd_desc.SCSI$L_FLAGS = SCSI$K_READ | SCSI$K_FL_ENAB_DIS;
      cmd_desc.SCSI$A_CMD_ADDR = RequestSenseCDB;
      cmd_desc.SCSI$L_CMD_LEN = 6;
      cmd_desc.SCSI$A_DATA_ADDR = RequestSense;
      cmd_desc.SCSI$L_DATA_LEN = sizeof(RequestSense_T);
      cmd_desc.SCSI$L_PH_CH_TMOUT = 180;
      cmd_desc.SCSI$L_DISCON_TMOUT = 180;
      /* Issue the QIO to send the Request Sense Command. */
      Status = sys$qiow(MK_EFN, DeviceFD, IO$_DIAGNOSE, &cmd_iosb, 0, 0,
			&cmd_desc, sizeof(cmd_desc), 0, 0, 0, 0);
      if (FailureStatusP(Status))
	{
	  printf("?Error returned from REQUEST_SENSE(1): %%X%08lX\n", Status);
	  sys$exit(Status);
	}
      /* Check the VMS Status from QIO. */
      Status = cmd_iosb.SCSI$W_VMS_STAT;
      if (FailureStatusP(Status))
	{
	  printf("?Error returned from REQUEST_SENSE(2): %%X%08lX\n", Status);
	  sys$exit(Status);
	}
    }
  return Result;
}


static void VMS_DefineStatusSymbols(void)
{
  char SymbolName[32], SymbolValue[32];
  int StorageElementNumber;
  if (DataTransferElementFull)
    {
      /* Define MTX_DTE Symbol (environment variable) as 'FULL:n'. */
      sprintf(SymbolValue, "FULL:%d",
	      DataTransferElementSourceStorageElementNumber);
      lib$set_symbol(descr("MTX_DTE"), descr(SymbolValue), &2);
    }
  else
    {
      /* Define MTX_DTE Symbol (environment variable) as 'EMPTY'. */
      lib$set_symbol(descr("MTX_DTE"), descr("EMPTY"), &2);
    }
  /* Define MTX_MSZ Symbol (environment variable) "Magazine SiZe" as 'n'. */
  sprintf(SymbolValue, "%d", StorageElementCount);
  lib$set_symbol(descr("MTX_MSZ"), descr(SymbolValue), &2);
  for (StorageElementNumber = 1;
       StorageElementNumber <= StorageElementCount;
       StorageElementNumber++)
    {
      sprintf(SymbolName, "MTX_STE%02d", StorageElementNumber);
      strcpy(SymbolValue,
	     (StorageElementFull[StorageElementNumber] ? "FULL" : "EMPTY"));
      lib$set_symbol(descr(SymbolName), descr(SymbolValue), &2);
    }
}