pcompute.c

Fdisk 1.2.1 Freedos下硬盘分区软件

   =pDrive->pri_part_largest_free_space;
  long requested_size_in_cylinders=Number_Of_Cylinders(size_in_MB*2048);

  unsigned long computed_partition_size;
  unsigned long cylinder_size=(pDrive->total_head+1)*(pDrive->total_sect);

  if (pDrive->pri_part_largest_free_space == 0)
  	{
	//Qprintf("no space left for primary partitions\n");
  	return 99;
  	}

  //Qprintf("Creating primary partition type %02x size %luMB\n",numeric_type,size_in_MB);

  /* Ensure that an empty primary partition exists. */
  for (empty_partition_number = 99, index = 0; index < 4; index++)
    {
     if (pDrive->pri_part[index].num_type==0) 
      {
      empty_partition_number=index;           
      break;
      }
    }

  /* If all primary partitions are full, report failure. */
  if(empty_partition_number==99) return(99);

  /* Adjust the size of the partition to fit boundaries, if necessary. */
  if(requested_size_in_cylinders>maximum_size_in_cylinders)
   requested_size_in_cylinders=maximum_size_in_cylinders;

  /* If the requested size of the partition is close to the end of the */
  /* maximum available space, fill the maximum available space.        */
  /* This ensures more aggressive use of the hard disk.                */
  if( (maximum_size_in_cylinders - 3) <= requested_size_in_cylinders)
   requested_size_in_cylinders = maximum_size_in_cylinders;

  /* Make sure the starting cylinder of an extended partition is at least  */
  /* 1.  If the cylinder number is 0, increment it to 1.                   */
  if( (numeric_type==5) || (numeric_type==0x0f) )
    {
    if(pDrive->pp_largest_free_space_start_cyl==0)
      {
      pDrive->pp_largest_free_space_start_cyl=1;
      requested_size_in_cylinders--;
      }
    }

  /* Re-obtain a partition type, if applicable. */
  if( (numeric_type!=5) && (numeric_type!=0x0f) )
   numeric_type=Partition_Type_To_Create(
		   ( ( (requested_size_in_cylinders+1)
		   *(pDrive->total_head+1)
		   *(pDrive->total_sect) ) / 2048 ),
		   numeric_type);

  /* Compute the ending cylinder of the partition */
  computed_ending_cylinder
   =pDrive->pp_largest_free_space_start_cyl
   +requested_size_in_cylinders-1;

  /* Compute the size of the partition. */
  computed_partition_size=(requested_size_in_cylinders)*cylinder_size;

  newPartition = &pDrive->pri_part[empty_partition_number];


  newPartition->active_status=0;
  newPartition->num_type=numeric_type;

  newPartition->start_cyl=pDrive->pp_largest_free_space_start_cyl;

  /* If the starting cylinder is 0, then the starting head is 1...otherwise */
  /* the starting head is 1.                                                */
  if(pDrive->pp_largest_free_space_start_cyl==0)
    newPartition->start_head=1;
  else
    newPartition->start_head=0;
  newPartition->start_sect=1;

  newPartition->end_cyl  =computed_ending_cylinder;
  newPartition->end_head =pDrive->total_head;
  newPartition->end_sect =pDrive->total_sect;

  if( newPartition->end_cyl>1023
   && (pDrive->ext_int_13==TRUE) )
    {
    numeric_type=LBA_Partition_Type_To_Create(numeric_type);
    newPartition->num_type=numeric_type;
    }

  if(newPartition->start_cyl>0)
    {
    newPartition->rel_sect
     =newPartition->start_cyl*(pDrive->total_head+1)*pDrive->total_sect;
    }
  else 
    newPartition->rel_sect=pDrive->total_sect;

  if(pDrive->pp_largest_free_space_start_cyl==0)
   computed_partition_size=computed_partition_size-pDrive->total_sect;

  newPartition->num_sect=computed_partition_size;

  newPartition->size_in_MB
   =Convert_Sect_To_MB(computed_partition_size);

  pDrive->part_values_changed=TRUE;
  flags.partitions_have_changed=TRUE;

  pDrive->pri_part_created[empty_partition_number]=TRUE;

  if( (numeric_type==5) || (numeric_type==0x0f) )
    {
    pDrive->ptr_ext_part= &pDrive->pri_part[empty_partition_number];
    pDrive->ext_part_num_sect=computed_partition_size;
    pDrive->ext_part_size_in_MB=size_in_MB;
    }

#ifdef DEBUG
  if(debug.create_partition==TRUE)
    {
    Clear_Screen(NULL);
    Print_Centered(1,"int Create_Primary_Partition(int numeric_type,long size_in_MB)",BOLD);
    printAt( 4, 3,"int numeric_type=%d",numeric_type);
    printAt( 4, 4,"long size_in_MB=%d",size_in_MB);
    printAt( 4, 5,"empty_partition_number=%d",empty_partition_number);

    printAt( 4, 8,"New Partition Information:");
    printAt( 4,10,"Starting Cylinder:  %d",newPartition->start_cyl);
    printAt( 4,11,"Starting Head:      %d",newPartition->start_head);
    printAt( 4,12,"Starting Sector:    %lu",newPartition->start_sect);

    printAt(40,10,"Ending Cylinder:    %d",newPartition->end_cyl);
    printAt(40,11,"Ending Head:        %d",newPartition->end_head);
    printAt(40,11,"Ending Sector:      %d",newPartition->end_sect);

    printAt( 4,14,"Relative Sectors:   %lu",newPartition->rel_sect);

    printAt(40,14,"Size of partition in MB:    %lu",newPartition->size_in_MB);

    Pause();
    }
#endif

  return(empty_partition_number);
}

/* Delete Logical DOS Drive */
void Delete_Logical_Drive(int logical_drive_number)
{
  int index;

  Partition_Table *pDrive = &part_table[flags.drive_number-0x80];

  /* Zero out the partition table entry for the logical drive. */
  pDrive->log_drive[logical_drive_number].num_type=0;

  strcpy(pDrive->log_drive[logical_drive_number].vol_label,"           ");

  pDrive->log_drive[logical_drive_number].start_cyl  = 0;
  pDrive->log_drive[logical_drive_number].start_head = 0;
  pDrive->log_drive[logical_drive_number].start_sect = 0;

  pDrive->log_drive[logical_drive_number].end_cyl    = 0;
  pDrive->log_drive[logical_drive_number].end_head   = 0;
  pDrive->log_drive[logical_drive_number].end_sect   = 0;

  pDrive->log_drive[logical_drive_number].rel_sect   = 0;
  pDrive->log_drive[logical_drive_number].num_sect   = 0;

  pDrive->log_drive[logical_drive_number].size_in_MB = 0;

  /* If the logical drive to be deleted is not the first logical drive.     */
  /* Assume that there are extended partition tables after this one.  If    */
  /* there are not any more extended partition tables, nothing will be      */
  /* harmed by the shift.                                                   */
  if(logical_drive_number>0)
    {
    /* Move the extended partition information from this table to the       */
    /* previous table.                                                      */
    pDrive->next_ext[(logical_drive_number-1)].start_cyl
     =pDrive->next_ext[logical_drive_number].start_cyl;

    pDrive->next_ext[(logical_drive_number-1)].start_head
     =pDrive->next_ext[logical_drive_number].start_head;

    pDrive->next_ext[(logical_drive_number-1)].start_sect
     =pDrive->next_ext[logical_drive_number].start_sect;

    pDrive->next_ext[(logical_drive_number-1)].end_cyl
     =pDrive->next_ext[logical_drive_number].end_cyl;

    pDrive->next_ext[(logical_drive_number-1)].end_head
     =pDrive->next_ext[logical_drive_number].end_head;

    pDrive->next_ext[(logical_drive_number-1)].end_sect
     =pDrive->next_ext[logical_drive_number].end_sect;

    pDrive->next_ext[(logical_drive_number-1)].rel_sect
     =pDrive->next_ext[logical_drive_number].rel_sect;

    pDrive->next_ext[(logical_drive_number-1)].num_sect
     =pDrive->next_ext[logical_drive_number].num_sect;

    /* Shift all the following extended partition tables left by 1.         */
    index=logical_drive_number;

    do
      {
      pDrive->log_drive[index].num_type
       =pDrive->log_drive[(index+1)].num_type;

      strcpy(pDrive->log_drive[index].vol_label
       ,pDrive->log_drive[(index+1)].vol_label);

      pDrive->log_drive[index].start_cyl
       =pDrive->log_drive[(index+1)].start_cyl;
      pDrive->log_drive[index].start_head
       =pDrive->log_drive[(index+1)].start_head;
      pDrive->log_drive[index].start_sect
       =pDrive->log_drive[(index+1)].start_sect;

      pDrive->log_drive[index].end_cyl
       =pDrive->log_drive[(index+1)].end_cyl;
      pDrive->log_drive[index].end_head
       =pDrive->log_drive[(index+1)].end_head;
      pDrive->log_drive[index].end_sect
       =pDrive->log_drive[(index+1)].end_sect;

      pDrive->log_drive[index].rel_sect
       =pDrive->log_drive[(index+1)].rel_sect;
      pDrive->log_drive[index].num_sect
       =pDrive->log_drive[(index+1)].num_sect;

      pDrive->log_drive[index].size_in_MB
       =pDrive->log_drive[(index+1)].size_in_MB;

      pDrive->next_ext[index].num_type
       =pDrive->next_ext[(index+1)].num_type;

      pDrive->next_ext[index].start_cyl
       =pDrive->next_ext[(index+1)].start_cyl;
      pDrive->next_ext[index].start_head
       =pDrive->next_ext[(index+1)].start_head;
      pDrive->next_ext[index].start_sect
       =pDrive->next_ext[(index+1)].start_sect;

      pDrive->next_ext[index].end_cyl
       =pDrive->next_ext[(index+1)].end_cyl;
      pDrive->next_ext[index].end_head
       =pDrive->next_ext[(index+1)].end_head;
      pDrive->next_ext[index].end_sect
       =pDrive->next_ext[(index+1)].end_sect;

      pDrive->next_ext[index].rel_sect
       =pDrive->next_ext[(index+1)].rel_sect;
      pDrive->next_ext[index].num_sect
       =pDrive->next_ext[(index+1)].num_sect;

      if(pDrive->log_drive[index].num_type > 0)
	{
	pDrive->next_ext_exists[(index-1)]=TRUE;
	}
      else
	{
	pDrive->next_ext_exists[(index-1)]=FALSE;
	}

      index++;
      }while(index<22);
    }
  pDrive->num_of_log_drives--;

  /* If there aren't any more logical drives, clear the extended        */
  /* partition table to prevent lockups by any other partition utils.   */
  if(pDrive->num_of_log_drives==0)
    {
    index=0;
    do
      {
      pDrive->log_drive[index].num_type   = 0;

      pDrive->log_drive[index].start_cyl  = 0;
      pDrive->log_drive[index].start_head = 0;
      pDrive->log_drive[index].start_sect = 0;

      pDrive->log_drive[index].end_cyl    = 0;
      pDrive->log_drive[index].end_head   = 0;
      pDrive->log_drive[index].end_sect   = 0;

      pDrive->log_drive[index].rel_sect   = 0;
      pDrive->log_drive[index].num_sect   = 0;

      pDrive->log_drive[index].size_in_MB = 0;
      pDrive->log_drive_created[index]    = FALSE;

      pDrive->next_ext_exists[index]      = FALSE;

      pDrive->next_ext[index].num_type    = 0;

      pDrive->next_ext[index].start_cyl   = 0;
      pDrive->next_ext[index].start_head  = 0;
      pDrive->next_ext[index].start_sect  = 0;

      pDrive->next_ext[index].end_cyl     = 0;
      pDrive->next_ext[index].end_head    = 0;
      pDrive->next_ext[index].end_sect    = 0;

      pDrive->next_ext[index].rel_sect    = 0;
      pDrive->next_ext[index].num_sect    = 0;

      index++;
      }while(index<24);
    }

  pDrive->part_values_changed=TRUE;
  flags.partitions_have_changed=TRUE;
}

/* Delete Primary Partition */
void Delete_Primary_Partition(int partition_number)
{
  int index;
  Partition_Table *pDrive = &part_table[flags.drive_number-0x80];

  /* If partition_number is an extended partition, first delete the */
  /* extended partition.                                            */
  if( (pDrive->pri_part[partition_number].num_type==5)
    || (pDrive->pri_part[partition_number].num_type==0x0f) )
    {
    pDrive->ptr_ext_part=NULL;

    pDrive->ext_part_size_in_MB=0;
    pDrive->ext_part_num_sect=0;
    pDrive->ext_part_largest_free_space=0;

    pDrive->log_drive_largest_free_space_location=0;
    pDrive->log_drive_free_space_start_cyl=0;
    pDrive->log_drive_free_space_end_cyl=0;

    pDrive->num_of_log_drives=0;

    index=0;
    do
      {
      memset(pDrive->log_drive,0,sizeof(pDrive->log_drive[0]));

      pDrive->next_ext_exists[index]=0;

      memset(pDrive->next_ext,0,sizeof(pDrive->next_ext[0]));

      index++;
      }while(index<23);
    }


  memset(&pDrive->pri_part[partition_number],0,sizeof(pDrive->pri_part[0]));
  flags.partitions_have_changed=TRUE;
}

/* Determine the locations of free space in the partition table */
void Determine_Free_Space()
{
  int first_used_partition=UNUSED;
  int last_used_partition=UNUSED;
  int index;
  int sub_index;