tapeinfo.c

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

/* Copyright 2000 Enhanced Software Technologies Inc.
 *   Released under terms of the GNU General Public License as
 * required by the license on 'mtxl.c'.
 * $Date: 2001/06/19 21:51:32 $
 * $Revision: 1.2 $
 */

/*#define DEBUG_PARTITION */
/*#define DEBUG 1 */

/* What this does: This basically dumps out the contents of the following
 * pages:
 *
 * Inquiry -- prints full inquiry info. If it's not a tape drive, this is
 * the end of things.
 *    DeviceType:
 *    Manufacturer:
 *    ProdID:  
 *    ProdRevision:
 *
 * Log Sense: TapeAlert Page (if supported):
 *    TapeAlert:[message#]<Message>  e.g. "TapeAlert:[22]Cleaning Cartridge Worn Out"
 *  
 * Mode Sense: 
 *  Data Compression Page:
 *    DataCompEnabled:<yes|no>
 *    DataCompCapable:<yes|no>
 *    DataDeCompEnabled:<yes|no>
 *    CompType:<number>
 *    DeCompType:<number>
 *
 *  Device Configuration Page:
 *    ActivePartition:<#>
 *    DevConfigComp:<#>    -- the compression byte in device config page.
 *    EarlyWarningSize:<#> -- size of early warning buffer?
 *
 *  Medium Partition Page:
 *    NumPartitions:<#>
 *    MaxPartitions:<#>
 *    Partition[0]:<size>
 *    Partition[1]:<size>...
 *
 * Read Block Limits command:
 *    MinBlock:<#>  -- Minimum block size.
 *    MaxBlock:<#>  -- Maximum block size. 
 */

#include <stdio.h>
#include <string.h>
#include "mtx.h"
#include "mtxl.h"

char  *argv0;

void usage(void) {
  FatalError("Usage: tapeinfo -f <generic-device>\n");
}

/* A table for printing out the peripheral device type as ASCII. */ 
static char *PeripheralDeviceType[32] = {
  "Disk Drive",
  "Tape Drive",
  "Printer",
  "Processor",
  "Write-once",
  "CD-ROM",
  "Scanner",
  "Optical",
  "Medium Changer",
  "Communications",
  "ASC IT8",
  "ASC IT8",
  "RAID Array",
  "Enclosure Services",
  "OCR/W",
  "Bridging Expander", /* 0x10 */
  "Reserved",  /* 0x11 */
  "Reserved", /* 0x12 */
  "Reserved",  /* 0x13 */
  "Reserved",  /* 0x14 */
  "Reserved",  /* 0x15 */
  "Reserved",  /* 0x16 */
  "Reserved",  /* 0x17 */
  "Reserved",  /* 0x18 */
  "Reserved",  /* 0x19 */
  "Reserved",  /* 0x1a */
  "Reserved",  /* 0x1b */
  "Reserved",  /* 0x1c */
  "Reserved",  /* 0x1d */
  "Reserved",  /* 0x1e */
  "Unknown"    /* 0x1f */
};



/* we call it MediumChangerFD for history reasons, sigh. */

/* now to print inquiry information: Copied from other one.... */

static void ReportInquiry(DEVICE_TYPE MediumChangerFD)
{
  RequestSense_T RequestSense;
  Inquiry_T *Inquiry;
  int i;

  Inquiry = RequestInquiry(MediumChangerFD,&RequestSense);
  if (Inquiry == NULL) 
    {
      PrintRequestSense(&RequestSense);
      FatalError("INQUIRY Command Failed\n");
    }
  
  printf("Product Type: %s\n",PeripheralDeviceType[Inquiry->PeripheralDeviceType]);
  printf("Vendor ID: '");
  for (i = 0; i < sizeof(Inquiry->VendorIdentification); i++)
    printf("%c", Inquiry->VendorIdentification[i]);
  printf("'\nProduct ID: '");
  for (i = 0; i < sizeof(Inquiry->ProductIdentification); i++)
    printf("%c", Inquiry->ProductIdentification[i]);
  printf("'\nRevision: '");
  for (i = 0; i < sizeof(Inquiry->ProductRevisionLevel); i++)
    printf("%c", Inquiry->ProductRevisionLevel[i]);
  printf("'\n");\
  if (Inquiry->MChngr) {  /* check the attached-media-changer bit... */
    printf("Attached Changer: Yes\n");
  } else {
    printf("Attached Changer: No\n");
  }
  free(Inquiry);  /* well, we're about to exit, but ... */
}




/* Okay, now for the Log Sense Tape Alert Page (if supported): */
#define TAPEALERT_SIZE 2048  /* max size of tapealert buffer. */ 
#define MAX_TAPE_ALERT 0x41

static char *tapealert_messages[]= {
  "Undefined", /* 0 */
  "         Read: Having problems reading (slowing down)", /* 1 */
  "        Write: Having problems writing (losing capacity)", /* 2 */
  "   Hard Error: Uncorrectable read/write error", /* 3 */
  "        Media: Media Performance Degraded, Data Is At Risk", /* 4 */
  " Read Failure: Tape faulty or tape drive broken", /* 5 */
  "Write Failure: Tape faulty or tape drive broken", /* 6 */
  "   Media Life: The tape has reached the end of its useful life", /* 7 */
  "Not Data Grade:Replace cartridge with one  containing data grade tape",/*8*/
  "Write Protect: Attempted to write to a write-protected cartridge",/*9 */
  "   No Removal: Cannot unload, initiator is preventing media removal", /*a*/
  "Cleaning Media:Cannot back up or restore to a cleaning cartridge", /* b */
  "   Bad Format: The loaded tape contains data in an unsupported format", /*c */
  " Snapped Tape: The data cartridge contains a broken tape", /* d */
  "Undefined", /* e */
  "Undefined", /* f */
  "Undefined", /* 10 */
  "Undefined", /* 11 */
  "Undefined", /* 12 */
  "Undefined", /* 13 */
  "    Clean Now: The tape drive neads cleaning NOW", /* 0x14 */
  "Clean Periodic:The tape drive needs to be cleaned at next opportunity", /* 0x15 */
  "Cleaning Media:Cannot clean because cleaning cartridge used up, insert new cleaning cartridge to clean the drive", /* 0x16 */
  "Undefined", /* 0x17 */
  "Undefined", /* 0x18 */
  "Undefined", /* 0x19 */
  "Undefined", /* 0x1a */
  "Undefined", /* 0x1b */
  "Undefined", /* 0x1c */
  "Undefined", /* 0x1d */
  "   Hardware A: Tape drive has a problem not read/write related", /* 0x1e */
  "   Hardware B: Tape drive has a problem not read/write related", /* 0x1f */
  "    Interface: Problem with SCSI interface between tape drive and initiator", /* 0x20 */
  "  Eject Media: The current operation has failed. Eject and reload media", /* 0x21 */
  "Download Fail: Attempt to download new firmware failed", /* 0x22 */
  "Undefined", /* 0x23 */
  "Undefined", /* 0x24 */
  "Undefined", /* 0x25 */
  "Undefined", /* 0x26 */
  "Undefined", /* 0x27 */
  "Loader Hardware A: Changer having problems communicating with tape drive", /* 0x28   40 */
  "Loader Stray Tape: Stray tape left in drive from prior error", /* 0x29 41 */
  "Loader Hardware B: Autoloader mechanism has a fault", /* 0x2a 42 */
  "  Loader Door: Loader door is open, please close it", /* 0x2b 43 */
  "Undefined", /* 0x2c */
  "Undefined", /* 0x2d */
  "Undefined", /* 0x2e */
  "Undefined", /* 0x2f */
  "Undefined", /* 0x30 */
  "Undefined", /* 0x31 */
  "Undefined", /* 0x32 */
  "Undefined", /* 0x33 */
  "Undefined", /* 0x34 */
  "Undefined", /* 0x35 */
  "Undefined", /* 0x36 */
  "Undefined", /* 0x37 */
  "Undefined", /* 0x38 */
  "Undefined", /* 0x39 */
  "Undefined", /* 0x3a */
  "Undefined", /* 0x3b */
  "Undefined", /* 0x3c */
  "Undefined", /* 0x3d */
  "Undefined", /* 0x3e */
  "Undefined", /* 0x3f */
  "Undefined" /* 0x40 */
};


struct tapealert_struct {
  int length;
  unsigned char *data;
};
  
  
static struct tapealert_struct *RequestTapeAlert(DEVICE_TYPE fd, RequestSense_T *sense) {
  CDB_T CDB;
  
  struct tapealert_struct *result;
  int i,tapealert_len,result_idx;
  
  unsigned char buffer[TAPEALERT_SIZE];
  unsigned char *walkptr;

  slow_bzero(buffer,TAPEALERT_SIZE); /*zero it... */

  /* now to create the CDB block: */
  CDB[0]=0x4d;   /* Log Sense */
  CDB[1]=0;   
  CDB[2]=0x2e;   /* Tape Alert Page. */
  CDB[3]=0;
  CDB[4]=0;
  CDB[5]=0;
  CDB[6]=0;
  CDB[7]=TAPEALERT_SIZE>>8 & 0xff;  /* hi byte, allocation size */
  CDB[8]=TAPEALERT_SIZE & 0xff;     /* lo byte, allocation size */
  CDB[9]=0;  /* reserved */ 

  if (SCSI_ExecuteCommand(fd,Input,&CDB,10,buffer,TAPEALERT_SIZE,sense)!=0){
    return NULL;
  }

  result=xmalloc(sizeof(struct tapealert_struct));

  /* okay, we have stuff in the result buffer: the first 4 bytes are a header:
   * byte 0 should be 0x2e, byte 1 == 0, bytes 2,3 tell how long the
   * tapealert page is. 
   */
  if ((buffer[0]&0x3f) != 0x2e) {
    result->data=NULL;
    result->length=0;
    return result;
  }

  tapealert_len=(((int)buffer[2])<<8) + buffer[3];
  

  if (!tapealert_len) {
    result->length=0;
    result->data=NULL;
    return result;
  }

  /* okay, now allocate data and move the buffer over there: */
  result->length=MAX_TAPE_ALERT;
  result->data=xzmalloc(MAX_TAPE_ALERT); /* alloc & zero. */
  
  walkptr=&buffer[4];
  i=0;
  while (i<tapealert_len) {
    

    result_idx=(((int)walkptr[0])<<8) + walkptr[1]; /* the parameter #. */
    if (result_idx > 0 && result_idx < MAX_TAPE_ALERT) {
      if (walkptr[4]) {
	result->data[result_idx]=1; 
      } else {
	result->data[result_idx]=0;
      }
#ifdef DEBUGOLD1
      fprintf(stderr,"Alert[0x%x]=%d\n",result_idx,result->data[result_idx]);
      fflush(stderr);
#endif
    } else {
      FatalError("Invalid tapealert page: %d\n",result_idx);
    }
    i=i+4+walkptr[3]; /* length byte! */
    walkptr=walkptr+4+walkptr[3]; /* next! */
  }
  return result;
}

static void ReportTapeAlert(DEVICE_TYPE fd) {
  /* we actually ignore a bad sense reading, like might happen if the 
   * tape drive does not support the tapealert page. 
   */
  
  RequestSense_T RequestSense;
  
  struct tapealert_struct *result;
  int i;

  result=RequestTapeAlert(fd,&RequestSense);
  if (!result) return; /* sorry. Don't print sense here. */
  if (!result->length) return; /* sorry, no alerts valid. */
  
  for (i=0;i<result->length;i++) {
    if (result->data[i]) {
      printf("TapeAlert[%d]:%s.\n",i,tapealert_messages[i]);
    }
  }
  free(result->data);
  free(result);
  return;
}

static unsigned char
*mode_sense(DEVICE_TYPE fd, int pagenum, int alloc_len,  RequestSense_T *RequestSense) {
  CDB_T CDB;

  unsigned char *input_buffer; /*the input buffer -- has junk prepended to
				* actual sense page. 
				*/
  unsigned char *tmp;
  unsigned char *retval;  /* the return value. */
  int i,pagelen;

  if (alloc_len > 255) {
    FatalError("mode_sense(6) can only read up to 255 characters!\n");
  }

  input_buffer=(unsigned char *)xzmalloc(256); /* overdo it, eh? */

  /* clear the sense buffer: */
  slow_bzero((char *)RequestSense,sizeof(RequestSense_T));
  

  /* returns an array of bytes in the page, or, if not possible, NULL. */
  CDB[0]=0x1a; /* Mode Sense(6) */
  CDB[1]=0; 
  CDB[2]=pagenum; /* the page to read. */
  CDB[3]=0;
  CDB[4]=255; /* allocation length. This does max of 256 bytes! */
  CDB[5]=0;
  
  if (SCSI_ExecuteCommand(fd,Input,&CDB,6,
			  input_buffer,255,RequestSense) != 0) {
#ifdef DEBUG_MODE_SENSE
    fprintf(stderr,"Could not execute mode sense...\n");
    fflush(stderr);
#endif
    return NULL; /* sorry, couldn't do it. */
  }

  /* Oh hell, write protect is the only thing I have: always print
   * it if our mode page was 0x0fh, before skipping past buffer: 
   * if the media is *NOT* write protected, just skip, sigh. 
   *
   * Oh poops, the blocksize is reported in the block descriptor header
<   * too. Again, just print if our mode page was 0x0f...
   */
  if (pagenum == 0x0f) {
    int blocklen;
    if (input_buffer[2] & 0x80) {
      printf("WriteProtect: yes\n");
    }
    if (input_buffer[2] & 0x70) {
      printf("BufferedMode: yes\n");
    }
    if (input_buffer[1] ) {
      printf("Medium Type: 0x%x\n", input_buffer[1]);
    } else {
      printf("Medium Type: Not Loaded\n");
    }
    printf("Density Code: 0x%x\n", input_buffer[4]);
    /* Put out the block size: */
    blocklen=((int)input_buffer[9]<<16)+
      ((int)input_buffer[10]<<8)+
      input_buffer[11];