dteei.c

Linux磁盘测试的源代码,测试磁盘的读写性能

            break;
	}
	Fprint( "\n" );
        Fprint( "DEVGETINFO ELEMENT      CONTENTS\n" );
        Fprint( "------------------      --------\n" );
        Fprint( "status                  0x%x\n", p_disk->status );
        if( p_disk->status ) {
            Fprint( "                        " );
            if( p_disk->status & DKDEV_OFFLINE )
                Fprint( "OFFLINE " );
            if( p_disk->status & DKDEV_WRTPROT )
                Fprint( "WRTPROT " );
            if( p_disk->status & DKDEV_RDONLY )
                Fprint( "RDONLY " );
            if( p_disk->status & DKDEV_REMOVABLE )
                Fprint( "REMOVABLE " );
            if( p_disk->status & DKDEV_REMOVABLE )
                Fprint( "REMOVABLE " );
	}
        Fprint( "part_num                %d\n", p_disk->part_num );
        Fprint( "media_changes           %d\n", p_disk->media_changes );
        Fprint( "class                   %s\n", p_disk->class==DKDEV_CLS_FLPY_GENERIC ? "GENERIC"
                                              : p_disk->class==DKDEV_CLS_FLPY_3_DD2S ? "3_DD2S"
                                              : p_disk->class==DKDEV_CLS_FLPY_3_HD2S ? "3_HD2S"
                                              : p_disk->class==DKDEV_CLS_FLPY_3_ED2S ? "3_ED2S"
                                              : p_disk->class==DKDEV_CLS_FLPY_5_LD2S ? "5_LD2S"
                                              : p_disk->class==DKDEV_CLS_FLPY_5_DD1S ? "5_DD1S"
                                              : p_disk->class==DKDEV_CLS_FLPY_5_DD2S ? "5_DD2S"
                                              : p_disk->class==DKDEV_CLS_FLPY_5_HD2S ? "5_HD2S"
                                              : "<unrecognized>" );
        break;

      case  DEV_TAPE :
        p_tape = &p_info->devinfo.tape;
        if ( !p_tape->unit_status && !p_tape->media_status ) {
            break;
	}
        Fprint( "\n" );
        Fprint( "DEVGETINFO ELEMENT      CONTENTS\n");
        Fprint( "------------------      --------\n");
        Fprint( "media_status            0x%x\n", p_tape->media_status );
        if( p_tape->media_status ) {
            Fprint( "                        " );
            if( p_tape->media_status & TPDEV_BOM )
                Fprint( "BOM " );
            if( p_tape->media_status & TPDEV_EOM )
                Fprint( "EOM " );
            if( p_tape->media_status & TPDEV_WRTPROT )
                Fprint( "WrtProt " );
            if( p_tape->media_status & TPDEV_BLANK )
                Fprint( "Blank " );
            if( p_tape->media_status & TPDEV_WRITTEN )
                Fprint( "Written " );
            if( p_tape->media_status & TPDEV_SOFTERR )
                Fprint( "SoftERR " );
            if( p_tape->media_status & TPDEV_HARDERR )
                Fprint( "HardERR " );
            if( p_tape->media_status & TPDEV_DONE )
                Fprint( "Done " );
            if( p_tape->media_status & TPDEV_RETRY )
                Fprint( "Retry " );
            if( p_tape->media_status & TPDEV_ERASED )
                Fprint( "Erased " );
            if( p_tape->media_status & TPDEV_TPMARK )
                Fprint( "TPmark " );
            if( p_tape->media_status & TPDEV_SHRTREC )
                Fprint( "ShortRec " );
            if( p_tape->media_status & TPDEV_RDOPP )
                Fprint( "RD_Opposite " );
            if( p_tape->media_status & TPDEV_RWDING )
                Fprint( "Rewinding " );
            if( p_tape->media_status & TPDEV_POS_VALID )
                Fprint( "POS_VALID " );
            Fprint( "\n" );
	}
        Fprint( "unit_status             0x%x\n", p_tape->unit_status );
        if( p_tape->unit_status ) {
            Fprint( "                        " );
            if( p_tape->unit_status & TPDEV_READY )
                Fprint( "Ready " );
              else
                Fprint( "Offline " );
            if( p_tape->unit_status & TPDEV_NO_EOM )
                Fprint( "No_EOM_Warn " );
            if( p_tape->unit_status & TPDEV_HAS_LOADER )
                Fprint( "Loader " );
            if( p_tape->unit_status & TPDEV_1FM_ONCLOSE )
                Fprint( "1_FM_Close " );
              else
                Fprint( "2_FM_Close " );
            if( p_tape->unit_status & TPDEV_REW_ONCLOSE )
                Fprint( "Rewind " );
              else
                Fprint( "NO_Rewind " );
            if( p_tape->unit_status & TPDEV_COMPACTING )
                Fprint( "Compacting " );
            if( p_tape->unit_status & TPDEV_COMPRESSING )
                Fprint( "Compacting " );
            if( p_tape->unit_status & TPDEV_BUFFERED )
                Fprint( "Buffered " );
            Fprint( "\n" );
	}
        Fprint( "record_size             %ld\n", p_tape->recordsz );
        Fprint( "density (current)       %ld BPI\n", p_tape->density_bpi );
        Fprint( "density (on write)      %ld BPI\n", p_tape->density_bpi_wrt );
        if( p_tape->media_status & TPDEV_POS_VALID ) {
            Fprint( "Filemark Cnt            %ld\n", p_tape->fm_cnt );
            Fprint( "Record Cnt              %ld\n", p_tape->position );
	} else {
            Fprint( "Filemark Cnt            <Not Valid>\n" );
            Fprint( "Record Cnt              <Not Valid>\n" );
	}
        Fprint( "Class                   %d - ", ((int )p_tape->class ) & 0xFF );
        switch( p_tape->class ) {
          case  TPDEV_CLS_DLT :
            Fprint( "DLT (tk )\n" );
            break;
          case  TPDEV_CLS_RDAT :
            Fprint( "RDAT\n" );
            break;
          case  TPDEV_CLS_9TRK :
            Fprint( "9TRK\n" );
            break;
          case  TPDEV_CLS_QIC :
            Fprint( "QIC\n" );
            break;
          case  TPDEV_CLS_8MM :
            Fprint( "8MM\n" );
            break;
          case  TPDEV_CLS_3480 :
            Fprint( "3480\n" );
            break;
          case  TPDEV_CLS_UNKNOWN :
            Fprint( "<unspecified>\n" );
            break;
          default :
            Fprint( "<unrecognized>\n" );
            break;
	}
        break;
    }
    return;
}

#else /* !defined(ZULUOS) */

/*
 * Display the contents of the deviocget struct.
 * Args: fd a file descriptor of the already opened tape device.
 */
void
print_devio(int fd)
{
	struct devget	devinf;
	device_info_t	*devinfop;

	/*
	 * First, attempt to use the DEVGETINFO ioctl (preferred),
	 * if that fails, try the backward-compatibility ioctl
	 * DEVIOCGET.
	 */

	/* malloc this as this is a large structure */
	devinfop = (device_info_t *)malloc(sizeof(device_info_t));

	if (!(devinfop) || 
		(ioctl(fd, DEVGETINFO, (char *)devinfop) < 0) ||
		(devinfop->version != VERSION_1) || /* what a joke! */
		(devgetinfo_2_devio(devinfop, &devinf) != ESUCCESS)) {

		/* DEVGETINFO failure */
		if (devinfop)
			free(devinfop);
		devinfop = (device_info_t *)NULL;

		if (ioctl(fd, DEVIOCGET, (char *)&devinf) < 0) {
			report_error ("DEVIOCGET failed", FALSE);
			return;
		}
	}
	/*
	 * at this point we have a valid devinf struct and possibly
	 * a valid device_info struct.
	 */

	/*
	 * We keep the "status" information EXACTLY the same as before
	 * as there are most likely are user entities outthere that parse
	 * the "status" output. We'll follow the normal output with the
	 * additional devgetinfo information, if applicable.
	 */

	Fprint("\n");
	Fprint("DEVIOGET ELEMENT        CONTENTS\n");
	Fprint("----------------        --------\n");
	Fprint("category                ");
	switch(devinf.category) {
	    case DEV_TAPE:
		Fprint("DEV_TAPE\n");
		break;
	    case DEV_DISK:
		Fprint("DEV_DISK\n");
		break;
	    case DEV_TERMINAL:
		Fprint("DEV_TERMINAL\n");
		break;
	    case DEV_PRINTER:
		Fprint("DEV_PRINTER\n");
		break;
	    case DEV_SPECIAL:
		Fprint("DEV_SPECIAL\n");
		break;
	    default:
		Fprint("UNDEFINED VALUE (0x%x)\n", devinf.category);
		break;
	}
	Fprint("bus                     ");
	switch(devinf.bus) {
	    case DEV_UB:
		Fprint("DEV_UB\n");
		break;
	    case DEV_QB:
		Fprint("DEV_QB\n");
		break;
	    case DEV_MB:
		Fprint("DEV_MB\n");
		break;
	    case DEV_BI:
		Fprint("DEV_BI\n");
		break;
	    case DEV_CI:
		Fprint("DEV_CI\n");
		break;
	    case DEV_NB:
		Fprint("DEV_NB\n");
		break;
	    case DEV_MSI:
		Fprint("DEV_MSI\n");
		break;
	    case DEV_SCSI:
		Fprint("DEV_SCSI\n");
		break;
	    case DEV_UNKBUS:
		Fprint("DEV_UNKBUS\n");
		break;
	    default:
		Fprint("UNDEFINED VALUE (0x%x)\n", devinf.bus);
		break;
	}
	Fprint("interface               %s\n", devinf.interface);
	Fprint("device                  %s\n", devinf.device);
	Fprint("adpt_num                %d\n", devinf.adpt_num);
	Fprint("nexus_num               %d\n", devinf.nexus_num);
	Fprint("bus_num                 %d\n", devinf.bus_num);
	Fprint("ctlr_num                %d\n", devinf.ctlr_num);
	Fprint("slave_num               %d\n", devinf.slave_num);
	Fprint("dev_name                %s\n", devinf.dev_name);
	Fprint("unit_num                %d\n", devinf.unit_num);
	Fprint("soft_count              %u\n", devinf.soft_count);
	Fprint("hard_count              %u\n", devinf.hard_count);
	Fprint("stat                    0x%X\n", devinf.stat);
	if (devinf.stat) print_stat(devinf.stat);
	Fprint("category_stat           0x%X\n", devinf.category_stat);
	if (devinf.category_stat) print_category(devinf.category_stat,devinfop);

	/* now print any additional DEVGETINFO data */
	if (devinfop) {
		v1_tape_dev_info_t *tapep;

		tapep = (v1_tape_dev_info_t *)&devinfop->v1.devinfo;

		Fprint("\n");
		Fprint("DEVGETINFO ELEMENT      CONTENTS\n");
		Fprint("------------------      --------\n");
		Fprint("media_status            0x%x\n", tapep->media_status);
		if (tapep->media_status) {
		    Fprint("                        ");
		    if (tapep->media_status & TPDEV_BOM)
			Fprint("BOM ");
		    if (tapep->media_status & TPDEV_EOM)
			Fprint("EOM ");
		    if (tapep->media_status & TPDEV_WRTPROT)
			Fprint("WrtProt ");
		    if (tapep->media_status & TPDEV_BLANK)
			Fprint("Blank ");
		    if (tapep->media_status & TPDEV_WRITTEN)
			Fprint("Written ");
		    if (tapep->media_status & TPDEV_SOFTERR)
			Fprint("SoftERR ");
		    if (tapep->media_status & TPDEV_HARDERR)
			Fprint("HardERR ");
		    if (tapep->media_status & TPDEV_DONE)
			Fprint("Done ");
		    if (tapep->media_status & TPDEV_RETRY)
			Fprint("Retry ");
		    if (tapep->media_status & TPDEV_ERASED)
			Fprint("Erased ");
		    if (tapep->media_status & TPDEV_TPMARK)
			Fprint("TPmark ");
		    if (tapep->media_status & TPDEV_SHRTREC)
			Fprint("ShortRec ");
		    if (tapep->media_status & TPDEV_RDOPP)
			Fprint("RD_Opposite ");
		    if (tapep->media_status & TPDEV_RWDING)
			Fprint("Rewinding ");
		    if (tapep->media_status & TPDEV_POS_VALID)
			Fprint("POS_VALID ");
		    Fprint("\n");
		}
		Fprint("unit_status             0x%x\n", tapep->unit_status);
		if (tapep->unit_status) {
		    Fprint("                        ");
		    if (tapep->unit_status & TPDEV_READY)
			Fprint("Ready ");
		    else
			Fprint("Offline ");
		    if (tapep->unit_status & TPDEV_NO_EOM)
			Fprint("No_EOM_Warn ");
		    if (tapep->unit_status & TPDEV_HAS_LOADER)
			Fprint("Loader ");
		    if (tapep->unit_status & TPDEV_1FM_ONCLOSE)
			Fprint("1_FM_Close ");
		    else
			Fprint("2_FM_Close ");
		    if (tapep->unit_status & TPDEV_REW_ONCLOSE)
			Fprint("Rewind ");
		    else
			Fprint("NO_Rewind ");
		    if (tapep->unit_status & TPDEV_COMPACTING)
			Fprint("Compacting ");
		    if (tapep->unit_status & TPDEV_COMPRESSING)
			Fprint("Compacting ");
		    if (tapep->unit_status & TPDEV_BUFFERED)
			Fprint("Buffered ");
		    Fprint("\n");
		}
		Fprint("record_size             %ld\n", tapep->recordsz);
		Fprint("density (current)       %ld BPI\n", tapep->density_bpi);
		Fprint("density (on write)      %ld BPI\n", tapep->density_bpi_wrt);
		if (tapep->media_status & TPDEV_POS_VALID) {
			Fprint("Filemark Cnt            %ld\n", tapep->fm_cnt);
			Fprint("Record Cnt              %ld\n", tapep->position);
		} else {
			Fprint("Filemark Cnt            %s\n", not_valid_str);
			Fprint("Record Cnt              %s\n", not_valid_str);
		}
		Fprint("Class                   %d - ", ((int)tapep->class) & 0xFF);
		switch (tapep->class) {
		case TPDEV_CLS_DLT:
			Fprint("DLT (tk)\n");
			break;
		case TPDEV_CLS_RDAT:
			Fprint("RDAT\n");
			break;
		case TPDEV_CLS_9TRK:
			Fprint("9TRK\n");
			break;
		case TPDEV_CLS_QIC:
			Fprint("QIC\n");
			break;
		case TPDEV_CLS_8MM:
			Fprint("8MM\n");
			break;
		case TPDEV_CLS_3480:
			Fprint("3480\n");
			break;
		case TPDEV_CLS_UNKNOWN:
			Fprint("<unspecified>\n");
			break;
		default:
			Fprint("<unrecognized>\n");
			break;
		}
		free(devinfop);
	}
	return;
}

#endif /* defined(ZULUOS) */

/*
 * Decode and display the EEI status:
 */
void
print_eei(DEV_EEI_STATUS *eei)
{
	if (eei->version == 0) {
	    PrintAscii ("EEI Information", not_valid_str, PNL);
	    return;
	}
	Fprint("\nCAM Extended Error Information:\n\n");
	PrintHex ("EEI Version", eei->version, PNL);
	PrintAscii ("EEI Status", "", DNL);
	print_eei_status (eei->status);

	PrintHex ("EEI Valid Flags", eei->flags, DNL);