操作系统开发

开发平台：
WINDOWS

HDSTRUCT.H：源码内容
							/*
	FIPS - the First nondestructive Interactive Partition Splitting program

	Module hdstruct.h

	RCS - Header:
	$Header: c:/daten/fips/source/main/RCS/hdstruct.h 1.4 1995/01/19 00:01:26 schaefer Exp schaefer $

	Copyright (C) 1993 Arno Schaefer

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	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.


	Report problems and direct all questions to:

	schaefer@rbg.informatik.th-darmstadt.de
*/

#ifndef HDSTRUCT_H
#define HDSTRUCT_H

#include "types.h"
#include "disk_io.h"


/* ----------------------------------------------------------------------- */
/* Class root_sector - derived from structure sector                        */
/* Must be initialized with a pointer to a physical_drive object           */
/* Read() and Write() read/write sector 0 of physical drive                */
/* ----------------------------------------------------------------------- */

class root_sector:public sector
{
	physical_drive *drive;
public:
// constructors and operators

	root_sector (physical_drive *drive) { root_sector::drive = drive; }
	root_sector (root_sector &rs);
	void operator= (root_sector &rs);


// functions

	int read (void) { return drive->read_sector (this, 0); }
	int write (void) { return drive->write_sector (this, 0); }
};


/* ----------------------------------------------------------------------- */
/* Partition Info Structure                                                */
/* Each entry in the partition table contains this information             */
/* ----------------------------------------------------------------------- */

struct partition_info
{
	byte bootable;                  // 80h or 0
	byte start_head;                // location of first sector (boot_sector)
	word start_cylinder;
	byte start_sector;
	byte system;			// 1 = 12-bit FAT
					// 4 = 16-bit FAT & 16-bit sector number
					// 6 = 16-bit FAT & 32-bit sector number (BIGDOS)
	byte end_head;                  // location of last sector
	word end_cylinder;
	byte end_sector;
	dword start_sector_abs;         // = start_cylinder * heads * sectors
					// + start_head * sectors + start_sector - 1
	dword no_of_sectors_abs;        // = end_cylinder * heads * sectors + end_head * sectors
					// + end_sector - start_sector_abs
};


/* ----------------------------------------------------------------------- */
/* Partition Table Structure                                               */
/* The partition table consists of 4 entries for the 4 possible partitions */
/* Get() reads the partition table from the root_sector, put() writes the   */
/* data back into the root_sector buffer                                    */
/* ----------------------------------------------------------------------- */

struct partition_table
{
	partition_info partition_info[4];
	void get (root_sector *root_sector);
	void put (root_sector *root_sector);
};


/* ----------------------------------------------------------------------- */
/* Harddrive Class, derived from physical_drive                            */
/* Represents one physical harddrive. Must be initialized with the drive   */
/* number (0x80 for 1st HDD). Contains the root_sector and partition table. */
/* ----------------------------------------------------------------------- */

class harddrive:public physical_drive
{
	partition_table pr_partition_table;

public:
// constructors, destructors, operators

	harddrive (int number):physical_drive (number)
	{
		root_sector = new class root_sector (this);
	}
	harddrive (harddrive &hd):physical_drive (hd)
	{
		root_sector = new class root_sector (*(hd.root_sector));
		partition_table () = hd.partition_table ();
	}
	void operator= (harddrive &hd);
	~harddrive (void) { delete root_sector; }

// public data

	root_sector *root_sector;

// member access functions

	virtual partition_table &partition_table() { return pr_partition_table; }

// functions

	int read_root_sector (void) { return (root_sector->read ()); }
	int write_root_sector (void) { return (root_sector->write ()); }

	void get_partition_table (void);	// extract pt data from root sector
	void put_partition_table (void)		// put pt data into root sector
	{partition_table().put (root_sector);}
};

#endif

						