hdisk.c

可以格式化超过200G硬盘的格式化工具

/*
// Program:  Format
// Version:  0.90
// Written By:  Brian E. Reifsnyder
// Copyright:  2002 under the terms of the GNU GPL, Version 2
// Module Name:  hdisk.c
// Module Description:  Hard Drive Specific Functions
*/

#define HDISK


#include <stdlib.h>

#include "floppy.h"
#include "format.h"
#include "createfs.h"
#include "btstrct.h"
#include "hdisk.h"


void Get_Device_Parameters()
{
  unsigned long error_code=0;

  if(debug_prog==TRUE)
    {
    printf("[DEBUG]  Enter Get_Device_Parameters() function\n");
    }

  /* Get the device parameters for the logical drive */

  regs.h.ah=0x44;                     /* IOCTL Block Device Request          */
  regs.h.al=0x0d;
  regs.h.bl=param.drive_number + 1;
  regs.h.ch=0x08;                     /* Always 0x08...unless fs is FAT32                         */
  regs.h.cl=0x60;                     /* Get device parameters               */
  regs.x.dx=FP_OFF(&parameter_block);
  sregs.ds =FP_SEG(&parameter_block);
  parameter_block.use_current_bpb = 0;
  parameter_block.use_track_layout_fields = 0;
  parameter_block.all_sectors_same_size = 1;
  parameter_block.reserved = 0;

  intdosx(&regs, &regs, &sregs);

  error_code = regs.h.al;

  if (regs.x.cflag)
    {
    /* Add error trapping here */
    printf("\nCall to int 0x21, 0x440d 0x60, failed error %02x.\n", error_code);
    exit(1);
    }

  if(parameter_block.sectors_per_fat == 0)
    {
    /* Ok, this is assumed to be a FAT32 partition and it will be       */
    /* formatted as such.                                               */


    if(debug_prog==TRUE)
      {
      printf("[DEBUG]  FAT32 detected.\n");
      }

    param.fat_type = FAT32;

    /* Get the device parameters for the logical drive */

    regs.h.ah=0x44;                     /* IOCTL Block Device Request          */
    regs.h.al=0x0d;
    regs.h.bl=param.drive_number + 1;
    regs.h.ch=0x48;                     /* Always 0x48 for FAT32                         */
    regs.h.cl=0x60;                     /* Get device parameters               */
    regs.x.dx=FP_OFF(&parameter_block);
    sregs.ds =FP_SEG(&parameter_block);
    parameter_block.use_current_bpb = 0;
    parameter_block.use_track_layout_fields = 0;
    parameter_block.all_sectors_same_size = 1;
    parameter_block.reserved = 0;

    intdosx(&regs, &regs, &sregs);

    error_code = regs.h.al;

    if (regs.x.cflag)
      {
      /* Add error trapping here */
      printf("\nCall to int 0x21, 0x440d 0x60, failed error %02x.\n", error_code);
      exit(1);
      }

    }

  if(debug_prog==TRUE)
    {
    printf("[DEBUG]  Exit Get_Device_Parameters() function\n");
    }

}


void Get_DPB()
{
  if(param.fat_type!=FAT32)
    {
    regs.h.ah = 0x32;

    regs.h.dl = param.drive_number + 1;
    intdosx(&regs, &regs, &sregs);

/*
    if (regs.x.cflag )
	{
	    printf("INT 0x21/0x32/drive=%c failed\n", param.drive_number+'A');
	    exit(1);
	}
*/
    dpb = MK_FP(sregs.ds,regs.x.bx);

    segread(&sregs);                    /* restore defaults */
    }
  else
    {
    unsigned int drive_number = param.drive_number +1;

    unsigned int ext_param_block_seg = FP_SEG(&ext_parameter_block);
    unsigned int ext_param_block_off = FP_OFF(&ext_parameter_block);

#ifdef __TURBOC__
    {
      struct SREGS sregs;
      /* reactivated old Turbo C 2.01 style code -ea */
      /* also fixed that code. Turbo C 2.01 has no asm { ... } -ea */
      regs.x.ax = 0x7302;
      regs.x.cx = 0x003f;

      sregs.es = ext_param_block_seg;
      regs.x.di = ext_param_block_off;

      regs.x.si = 0xf1a6;

      regs.h.dl = drive_number;
      intdosx(&regs, &regs, &sregs);
   }
#else
    asm{
      mov ah,0x73
      mov al,0x02

      mov cx,0x003f

      mov dl,BYTE PTR drive_number

      mov es,WORD PTR ext_param_block_seg
      mov di,WORD PTR ext_param_block_off

      mov si,0xf1a6

      int 0x21

      }
#endif

/*
    if (regs.x.cflag )
	{
	    printf("INT 0x21/0x32/drive=%c failed\n", param.drive_number+'A');
	    exit(1);
	}
*/
/*    dpb = MK_FP(sregs.ds,regs.x.bx); */ /* for TC, must not use // -ea */

/*    segread(&sregs);                   */ /* restore defaults */
    }
}

void Set_DPB_Access_Flag()
{

  if(param.fat_type!=FAT32)
    {
    dpb->dpb_access_flag=0xff;

    regs.h.ah = 0x32;
    regs.h.dl = param.drive_number + 1;
    intdosx(&regs, &regs, &sregs);

    segread(&sregs);                    /* restore defaults */
    }
  else
    {
    unsigned char drive_no;

    unsigned dpb_format_struct_high;
    unsigned dpb_format_struct_low;

    struct
      {
      unsigned int  size;
      unsigned int  structure_version;
      unsigned long function_number;

      unsigned long field_1;
      unsigned long field_2;
      unsigned long field_3;
      unsigned long field_4;
      }dpb_for_format_structure;

    dpb_for_format_structure.size              = 0x18;
    dpb_for_format_structure.structure_version = 0x00;
    dpb_for_format_structure.function_number   = 0x02;
    dpb_for_format_structure.field_1           = 0x0;
    dpb_for_format_structure.field_2           = 0x0;
    dpb_for_format_structure.field_3           = 0x0;
    dpb_for_format_structure.field_4           = 0x0;

    drive_no=param.drive_number + 1;

    dpb_format_struct_high = FP_SEG(&dpb_for_format_structure);
    dpb_format_struct_low  = FP_OFF(&dpb_for_format_structure);

#ifdef __TURBOC__
    /* Turbo C 2.01 has no asm { ... } -ea */
    {
      union REGS r;
      struct SREGS s;
      r.x.ax = 0x7304;
      r.h.dl = drive_no;
      s.es = dpb_format_struct_high;
      r.x.di = dpb_format_struct_low;
      intdosx(&r, &r, &s);
    }
#else
    asm{
      mov ax,0x7304
      mov dl,BYTE PTR drive_no
      mov es,dpb_format_struct_high
      mov di,dpb_format_struct_low
      int 0x21
    }
#endif

    }
}

void Set_Hard_Drive_Media_Parameters()
{
  /* int index; */
  /* int result; */

  unsigned long number_of_sectors;

  param.media_type=HD;
  param.fat_type=FAT12;

  Get_Device_Parameters();
  Get_DPB();

  if(parameter_block.total_sectors!=0)
    {
    number_of_sectors = parameter_block.total_sectors;
    }
  else
    {
    number_of_sectors =  parameter_block.large_sector_count_high;
    number_of_sectors =  number_of_sectors<<16;
    number_of_sectors += parameter_block.large_sector_count_low;
    }

  drive_specs[HD].total_logical_sectors=number_of_sectors;

  /* Copy the returned BPB information into drive_specs. */
  memcpy(&drive_specs[HD].bytes_per_sector,&parameter_block.bytes_per_sector,25);

  /* Copy BPB into bpb_standard structure. */
  memcpy(&bpb_standard,&parameter_block.bytes_per_sector,25);

  /* If the file system is FAT32, copy the FAT32 BPB extension into     */
  /* bpb_fat32_ext.                                                     */
  if(param.fat_type==FAT32)
   memcpy(&bpb_fat32_ext,&parameter_block.sectors_per_fat_low,27);

  Get_FS_Info();
  if( (param.fat_type!=FAT32) && (file_sys_info.total_clusters>=4085) )
   param.fat_type=FAT16;

  param.size=number_of_sectors/2048;

  drive_statistics.bytes_total_disk_space
   =((unsigned long)drive_specs[param.media_type].bytes_per_sector*number_of_sectors)
   -((1+(2*(unsigned long)drive_specs[param.media_type].sectors_per_fat)
   +((unsigned long)drive_specs[param.media_type].root_directory_entries/16))
   *(unsigned long)drive_specs[param.media_type].bytes_per_sector);
  drive_statistics.bytes_available_on_disk
   =drive_statistics.bytes_total_disk_space;

  drive_statistics.bytes_in_each_allocation_unit
   =(unsigned long)drive_specs[param.media_type].sectors_per_cluster
   *(unsigned long)drive_specs[param.media_type].bytes_per_sector;
}