新买来的硬盘是未初始化的，以我的理解就是没有引导扇区的，通常是没有MBR，如下图磁盘1，右边有大小，但显示“未分配”，
 
左边显示“没有初始化”， 点鼠标右键就可以【初始化磁盘】。
 

 
 
初始化时可以选择MBR和GPT， MBR方式顶多支持2T硬盘的。
 
 
初始化后
 

 
 
初始化后可以新建简单卷了，之前是不行的：
 

 
 

 
 
CreateDisk(1, 3) 就是把磁盘1分为3个分区
 

 
 

 
 
奇怪，如果只分1个区，就是自动以NTFS格式化掉， 而分3个区，还会提示是否格式化。
 

 
 
如果想回到刚买回来的空白状态怎么办呢？ 用DestroyDisk()就可以了
 

 
 
代码： 
 
CPP：CMDiskManager.cpp
 

#include "stdafx.h"
#include "CMDiskManager.h"

CMDiskManager::CMDiskManager(){}

//获取磁盘大小,单位是MB
int CMDiskManager::GetDiskSize(DWORD vDiskNo)
{
	HANDLE hDevice;               // handle to the drive to be examined 
	BOOL bResult;                 // results flag
	DWORD junk;                   // discard results

	char diskPath[256];				//磁盘内部路径
	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	hDevice = CreateFile(TEXT(diskPath),  // drive 或者 用"\\\\.\\PhysicalDrive0"  代表第一块磁盘
		GENERIC_READ,                // no access to the drive
		FILE_SHARE_READ | // share mode
		FILE_SHARE_WRITE,
		NULL,             // default security attributes
		OPEN_EXISTING,    // disposition
		0,                // file attributes
		NULL);            // do not copy file attributes

	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		return (FALSE);
	}
	
	GET_LENGTH_INFORMATION pdg;
	bResult = DeviceIoControl(hDevice,  // device to be queried
		IOCTL_DISK_GET_LENGTH_INFO,  // operation to perform
		NULL, 0, // no input buffer
		&pdg, sizeof(pdg),     // output buffer
		&junk,                 // # bytes returned
		(LPOVERLAPPED)NULL);  // synchronous I/O

	CloseHandle(hDevice);

/*	INT64 nUseSize = disk_len.Length.QuadPart;
	INT64 sizeGB = nUseSize / 1014 / 1024 / 1024;
	CString szSize;
	szSize.Format(L"C盘大小 %I64d GB", sizeGB);
	*/
	int MB = pdg.Length.QuadPart >> 20;
	//CString s; 
	//s.Format("C盘大小 %f GB", MB/1024.0);
	//AfxMessageBox(s, 0, MB_OK);  
	//float x = (float) MB ;
	return MB  ;
}


/*
获取磁盘分区个数
vDiskNo:磁盘序号
*/
int CMDiskManager::GetPartNum(DWORD vDiskNo)
{
	char diskPath[256];				//磁盘内部路径
	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);
	HANDLE hDevice;               //硬盘句柄 handle to the drive to be examined
	BOOL result;                  //结果标志 results flag
	DWORD readed;                 // discard results

	hDevice = CreateFile(
		diskPath,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,           //default security attributes  
		OPEN_EXISTING, // disposition  
		0,              // file attributes  
		NULL
		);
	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());
		return int(-1);
	}

	DRIVE_LAYOUT_INFORMATION_EX* dl;
	DWORD tSize = 0x4000; // sizeof(DRIVE_LAYOUT_INFORMATION_EX) * 10;
	dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(tSize);
	if (NULL == dl)
	{
		(void)CloseHandle(hDevice);
		return (int)-2;
	}

	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
		NULL,
		0,
		dl,
		tSize,
		&readed,
		NULL
		);

	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_GET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return int(-3);
	}

	CString tPartitionStyle = "RAW";
	switch (dl->PartitionStyle){
	case 0:
		tPartitionStyle = "MBR";
		break;
	case 1:
		tPartitionStyle = "GPT";
		break;
	}

	//printf("dl->PartitionCount = %d", dl->PartitionCount);
	TRACE("dl->PartitionCount = %d, tPartitionStyle:%s \n", dl->PartitionCount, tPartitionStyle.GetBuffer());

	//printf("dl->PartitionCount = %d", dl->PartitionCount);
	int tRet = dl->PartitionCount/4;
	//TRACE("dl->PartitionCount tRet = %d", tRet);

	free(dl);
	(void)CloseHandle(hDevice);

	return tRet;
}

//读MBR信息
BOOL CMDiskManager::ReadMBR(int vDiskNo, LPVOID *pBuffer)
{
	HANDLE hDevice;
	DWORD dwSize;
	DWORD dwOverRead;
	BOOL bRet = TRUE;
	char diskPath[256];				//磁盘内部路径
	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	hDevice = CreateFile(TEXT(diskPath),
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		0,
		NULL);
	if (hDevice == INVALID_HANDLE_VALUE) {
		TRACE("Open \\\\.\\PhysicalDrive failed. Error=%u\n", GetLastError());
		return FALSE;
	}

	if (!DeviceIoControl(hDevice, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL)) {
		CloseHandle(hDevice);
		TRACE("FSCTL_LOCK_VOLUME \\\\.\\PhysicalDrive0 failed. Error=%u\n", GetLastError());
		return FALSE;
	}

	DISK_GEOMETRY Geometry;
	if (!DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &Geometry, sizeof(DISK_GEOMETRY), &dwSize, NULL)) {
		bRet = FALSE;
		TRACE("IOCTL_DISK_GET_DRIVE_GEOMETRY \\\\.\\PhysicalDrive0 failed. Error=%u\n", GetLastError());
		goto _out;
	}

	*pBuffer = (LPVOID)GlobalAlloc(GPTR, Geometry.BytesPerSector);
	if (*pBuffer) {
		if (!ReadFile(hDevice, *pBuffer, Geometry.BytesPerSector, &dwOverRead, NULL)) {
			printf("ReadFile \\\\.\\PhysicalDrive %u bytes failed. Error=%u\n", Geometry.BytesPerSector, GetLastError());
			bRet = FALSE;
		}
	}

_out:
	DeviceIoControl(hDevice, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL);
	CloseHandle(hDevice);
	return bRet;

}


/*
获取磁盘分区信息
vDiskNo:磁盘序号
*/
DWORD CMDiskManager::GetLayoutInfo(DWORD vDiskNo)
{
	char diskPath[256];				//磁盘内部路径
	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);
	HANDLE hDevice;               //硬盘句柄 handle to the drive to be examined
	BOOL result;                  //结果标志 results flag
	DWORD readed;                 // discard results
	  
	hDevice = CreateFile(
		diskPath,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,           //default security attributes  
		OPEN_EXISTING, // disposition  
		0,              // file attributes  
		NULL
		);
	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());
		return DWORD(-1);
	}

	DRIVE_LAYOUT_INFORMATION_EX* dl;
	DWORD tSize = 0x4000; // sizeof(DRIVE_LAYOUT_INFORMATION_EX) * 10;
	dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(tSize);
	if (NULL == dl)
	{
		(void)CloseHandle(hDevice);
		return (WORD)-1;
	}

	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
		NULL,
		0,
		dl,
		tSize,
		&readed,
		NULL
		);

	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_GET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	CString tPartitionStyle = "RAW";
	switch (dl->PartitionStyle){
	case 0:	
		tPartitionStyle = "MBR";
		break; 
	case 1:
		tPartitionStyle = "GPT";
		break;
	}

	//printf("dl->PartitionCount = %d", dl->PartitionCount);
	TRACE("dl->PartitionCount = %d, tPartitionStyle:%s", dl->PartitionCount, tPartitionStyle.GetBuffer());

	free(dl);
	(void)CloseHandle(hDevice);

	return 0;
}

/*
初始化磁盘，创建分区
vDiskNo:磁盘序号，千万要避开系统盘，系统盘一般是0
vPartNum:分区数，只要1个分区就可以了
*/
DWORD CMDiskManager::CreateDisk(DWORD vDiskNo, WORD vPartNum)
{
	printf("准备CreateDisk, vDiskNo=%d, vPartNum=%d \n", vDiskNo, vPartNum);

	//第0块磁盘是系统盘，不能格式化掉！！！但不排除某些情况下新插入的移动硬盘会是第0块磁盘
	if (0 == vDiskNo){
		printf("第0块磁盘是系统盘，不能格式化掉\n");
		return 0;
	}

	HANDLE hDevice;               //硬盘句柄 handle to the drive to be examined
	BOOL result;                  //结果标志 results flag
	DWORD readed;                 // discard results
	DWORD ret;
	WORD i;
	char diskPath[256];				//磁盘内部路径
	DISK_GEOMETRY pdg;
	DWORD sectorSize;			//扇区大小
	DWORD signature;			//签名
	LARGE_INTEGER diskSize;		//磁盘大小
	LARGE_INTEGER partSize;		//分区大小
	BYTE actualPartNum;			//实际上的分区数

	DWORD layoutStructSize;		//
	DRIVE_LAYOUT_INFORMATION_EX *dl;	//磁盘分区信息
	CREATE_DISK newDisk;		//创建磁盘（初始化？）

	//生成磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	actualPartNum = 4;
	if (vPartNum > actualPartNum)
	{
		printf("vPartNum > 4\n");
		return (WORD)-1;
	}

	hDevice = CreateFile(
		diskPath,
		GENERIC_READ | GENERIC_WRITE,
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,           //default security attributes  
		OPEN_EXISTING, // disposition  
		0,              // file attributes  
		NULL
		);
	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());
		return DWORD(-1);
	}

	// Create primary partition MBR
	//创建主分区的MBR
	printf("创建主分区的MBR\n");

	newDisk.PartitionStyle = PARTITION_STYLE_MBR;
	signature = (DWORD)time(0);     // 原为time(NULL),   get signature from current time
	newDisk.Mbr.Signature = signature;

	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_CREATE_DISK,
		&newDisk,
		sizeof(CREATE_DISK),
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_CREATE_DISK Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	//fresh the partition table
	//刷新分区表
	printf("刷新分区表\n");
	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_UPDATE_PROPERTIES,
		NULL,
		0,
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	//Now create the partitions
	//现在创建分区
	ret = GetDriveGeometry(vDiskNo, &pdg);
	if ((DWORD)-1 == ret)
	{
		return ret;
	}

	//扇区大小
	sectorSize = pdg.BytesPerSector;
	diskSize.QuadPart = pdg.Cylinders.QuadPart * pdg.TracksPerCylinder *
		pdg.SectorsPerTrack * pdg.BytesPerSector;       //calculate the disk size;
	partSize.QuadPart = diskSize.QuadPart / vPartNum;

	//分区结构大小
	layoutStructSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + (actualPartNum - 1) * sizeof(PARTITION_INFORMATION_EX);
	dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(layoutStructSize);
	if (NULL == dl)
	{
		(void)CloseHandle(hDevice);
		return (WORD)-1;
	}

	dl->PartitionStyle = (DWORD)PARTITION_STYLE_MBR;
	dl->PartitionCount = actualPartNum;
	dl->Mbr.Signature = signature;

	//clear the unused partitions
	//清除未用的分区
	printf("清除未用的分区\n");
	for (i = 0; i < actualPartNum; i++){
		dl->PartitionEntry[i].RewritePartition = 1;
		dl->PartitionEntry[i].Mbr.PartitionType = PARTITION_ENTRY_UNUSED;
	}

	//set the profile of the partitions
	for (i = 0; i < vPartNum; i++){
		dl->PartitionEntry[i].PartitionStyle = PARTITION_STYLE_MBR;
		dl->PartitionEntry[i].StartingOffset.QuadPart =
			(partSize.QuadPart * i) + ((LONGLONG)(pdg.SectorsPerTrack) * (LONGLONG)(pdg.BytesPerSector));   //32256
		dl->PartitionEntry[i].PartitionLength.QuadPart = partSize.QuadPart;
		dl->PartitionEntry[i].PartitionNumber = i + 1;
		dl->PartitionEntry[i].RewritePartition = TRUE;
		dl->PartitionEntry[i].Mbr.PartitionType = PARTITION_IFS;
		dl->PartitionEntry[i].Mbr.BootIndicator = FALSE;
		dl->PartitionEntry[i].Mbr.RecognizedPartition = TRUE;
		dl->PartitionEntry[i].Mbr.HiddenSectors =
			pdg.SectorsPerTrack + (DWORD)((partSize.QuadPart / sectorSize) * i);
	}
	//execute the layout  
	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
		dl,
		layoutStructSize,
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_SET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());
		free(dl);
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	//fresh the partition table
	printf("刷新分区表\n");
	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_UPDATE_PROPERTIES,
		NULL,
		0,
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());
		free(dl);
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	free(dl);
	(void)CloseHandle(hDevice);
	printf("CreateDisk完成\n");
	Sleep(3000);            //wait the operations take effect
	return 0;
}


//获取磁盘几何信息
BOOL CMDiskManager::GetDriveGeometry(DWORD vDiskNo, DISK_GEOMETRY *pdg)
{
	HANDLE hDevice; // handle to the drive to be examined
	BOOL bResult; // results flag
	DWORD junk; // discard results

	char diskPath[256];				//磁盘内部路径
	sprintf_s(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	hDevice = CreateFile(TEXT(diskPath), // drive
		0, // no access to the drive
		FILE_SHARE_READ | // share mode
		FILE_SHARE_WRITE,
		NULL, // default security attributes
		OPEN_EXISTING, // disposition
		0, // file attributes
		NULL); // do not copy file attributes

	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		return (FALSE);
	}

	bResult = DeviceIoControl(hDevice, // device to be queried
		IOCTL_DISK_GET_DRIVE_GEOMETRY, // operation to perform
		NULL, 0, // no input buffer
		pdg, sizeof(*pdg), // output buffer
		&junk, // # bytes returned
		(LPOVERLAPPED)NULL); // synchronous I/O

	CloseHandle(hDevice);

	return (bResult);
}


/******************************************************************************
* Function: delete the partition layout of the disk
删除磁盘分区信息（恢复出厂设置）
* input: disk, disk name
* output: N/A
* return: Succeed, 0
*         Fail, -1
******************************************************************************/
DWORD CMDiskManager::DestroyDisk(DWORD vDiskNo)
{
	if (0 == vDiskNo){
		//系统盘是0号盘，为了安全，不能删除
		return 0; 
	}

	HANDLE hDevice;               // handle to the drive to be examined
	BOOL result;                  // results flag
	DWORD readed;                 // discard results
	CHAR diskPath[256];

	sprintf(diskPath, "\\\\.\\PhysicalDrive%d", vDiskNo);

	hDevice = CreateFile(
		diskPath, // drive to open
		GENERIC_READ | GENERIC_WRITE,     // access to the drive
		FILE_SHARE_READ | FILE_SHARE_WRITE, //share mode
		NULL,             // default security attributes
		OPEN_EXISTING,    // disposition
		0,                // file attributes
		NULL            // do not copy file attribute
		);
	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
	{
		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());
		return DWORD(-1);
	}

	result = DeviceIoControl(
		hDevice,               // handle to device
		IOCTL_DISK_DELETE_DRIVE_LAYOUT, // dwIoControlCode
		NULL,                           // lpInBuffer
		0,                              // nInBufferSize
		NULL,                           // lpOutBuffer
		0,                              // nOutBufferSize
		&readed,      // number of bytes returned
		NULL        // OVERLAPPED structure
		);
	if (!result)
	{
		//fprintf(stderr, "IOCTL_DISK_DELETE_DRIVE_LAYOUT Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	//fresh the partition table
	result = DeviceIoControl(
		hDevice,
		IOCTL_DISK_UPDATE_PROPERTIES,
		NULL,
		0,
		NULL,
		0,
		&readed,
		NULL
		);
	if (!result)
	{
		fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());
		(void)CloseHandle(hDevice);
		return DWORD(-1);
	}

	(void)CloseHandle(hDevice);
	return 0;
}

/******************************************************************************
* Function:快速格式化某个磁盘，文件系统NTFS，
如果在CreateDisk()创建磁盘后，磁盘的文件系统是RAW的话，才需要调用该函数
* input: disk, disk name
* output: N/A
* return: Succeed, 0
*         Fail, 1
******************************************************************************/
DWORD CMDiskManager::FormatVolume(CHAR letter)
{
	DWORD ret;
	CHAR cmd[64];
	sprintf(cmd, "format %c: /FS:NTFS /Q /Y", letter);
	ret = (DWORD)system(cmd);
	return ret;
}

//获取第dwNum个磁盘的信息
void CMDiskManager::GetDiskInfo(DWORD &dwNum, CString chDriveInfo[])
{
	DWORD DiskCount = 0;

	//利用GetLogicalDrives()函数可以获取系统中逻辑驱动器的数量，函数返回的是一个32位无符号整型数据。  
	DWORD DiskInfo = GetLogicalDrives();

	//通过循环操作查看每一位数据是否为1，如果为1则磁盘为真,如果为0则磁盘不存在。  
	while (DiskInfo)
	{
		//通过位运算的逻辑与操作，判断是否为1  
		Sleep(10);
		if (DiskInfo & 1)
		{
			DiskCount++;
		}
		DiskInfo = DiskInfo >> 1;//通过位运算的右移操作保证每循环一次所检查的位置向右移动一位。*/  
	}

	if (dwNum < DiskCount)
	{
		return;//实际的磁盘数目大于dwNum  
	}
	dwNum = DiskCount;//将磁盘分区数量保存  


	//-------------------------------------------------------------------//  
	//通过GetLogicalDriveStrings()函数获取所有驱动器字符串信息长度  
	int DSLength = GetLogicalDriveStrings(0, NULL);

	CHAR* DStr = new CHAR[DSLength];
	memset(DStr, 0, DSLength);

	//通过GetLogicalDriveStrings将字符串信息复制到堆区数组中,其中保存了所有驱动器的信息。  
	GetLogicalDriveStrings(DSLength, DStr);

	int DType;
	int si = 0;
	BOOL fResult;
	unsigned _int64 i64FreeBytesToCaller;
	unsigned _int64 i64TotalBytes;
	unsigned _int64 i64FreeBytes;

	//读取各驱动器信息，由于DStr内部数据格式是A:\NULLB:\NULLC:\NULL，所以DSLength/4可以获得具体大循环范围  
	for (int i = 0; i<DSLength / 4; ++i)
	{
		Sleep(10);
		CString strdriver = DStr + i * 4;
		CString strTmp, strTotalBytes, strFreeBytes;
		DType = GetDriveType(strdriver);//GetDriveType函数，可以获取驱动器类型，参数为驱动器的根目录  
		switch (DType)
		{
		case DRIVE_FIXED:
		{
			strTmp.Format(_T("本地磁盘"));
		}
			break;
		case DRIVE_CDROM:
		{
			strTmp.Format(_T("DVD驱动器"));
		}
			break;
		case DRIVE_REMOVABLE:
		{
			strTmp.Format(_T("可移动磁盘"));
		}
			break;
		case DRIVE_REMOTE:
		{
			strTmp.Format(_T("网络磁盘"));
		}
			break;
		case DRIVE_RAMDISK:
		{
			strTmp.Format(_T("虚拟RAM磁盘"));
		}
			break;
		case DRIVE_UNKNOWN:
		{
			strTmp.Format(_T("虚拟RAM未知设备"));
		}
			break;
		default:
			strTmp.Format(_T("未知设备"));
			break;
		}

		//GetDiskFreeSpaceEx函数，可以获取驱动器磁盘的空间状态,函数返回的是个BOOL类型数据  
		fResult = GetDiskFreeSpaceEx(strdriver,
			(PULARGE_INTEGER)&i64FreeBytesToCaller,
			(PULARGE_INTEGER)&i64TotalBytes,
			(PULARGE_INTEGER)&i64FreeBytes);

		if (fResult)
		{
			strTotalBytes.Format(_T("磁盘总容量%.2fMB"), (float)i64TotalBytes / 1024 / 1024);
			strFreeBytes.Format(_T("磁盘剩余空间%.2fMB"), (float)i64FreeBytesToCaller / 1024 / 1024);
		}
		else
		{
			strTotalBytes.Format(_T(""));
			strFreeBytes.Format(_T(""));
		}
		chDriveInfo[i] = strTmp + _T("(") + strdriver + _T("):") + strTotalBytes + ", " +strFreeBytes;
		si += 4;
	}
}


/******************************************************************************

* Function: get disk's physical number from its drive letter
		根据逻辑盘符找到物理硬盘号

*           e.g. C-->0 (C: is on disk0)

* input: letter, drive letter

* output: N/A

* return: Succeed, disk number

*         Fail, -1

******************************************************************************/

//根据逻辑盘符找到物理硬盘号
DWORD CMDiskManager::GetPhysicalDriveFromPartitionLetter(CHAR letter)
{
	HANDLE hDevice;               // handle to the drive to be examined

	BOOL result;                 // results flag

	DWORD readed;                   // discard results

	STORAGE_DEVICE_NUMBER number;   //use this to get disk numbers
	
	CHAR path[256];

	sprintf(path, "\\\\.\\%c:", letter);

	hDevice = CreateFile(path, // drive to open

		GENERIC_READ | GENERIC_WRITE,    // access to the drive

		FILE_SHARE_READ | FILE_SHARE_WRITE,    //share mode

		NULL,             // default security attributes

		OPEN_EXISTING,    // disposition

		0,                // file attributes

		NULL);            // do not copy file attribute

	if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive

	{

		fprintf(stderr, "CreateFile() Error: %ld\n", GetLastError());

		return DWORD(-1);
	}
	
	result = DeviceIoControl(

		hDevice,                // handle to device

		IOCTL_STORAGE_GET_DEVICE_NUMBER, // dwIoControlCode

		NULL,                            // lpInBuffer

		0,                               // nInBufferSize

		&number,           // output buffer

		sizeof(number),         // size of output buffer

		&readed,       // number of bytes returned

		NULL      // OVERLAPPED structure

		);

	if (!result) // fail
	{

		fprintf(stderr, "IOCTL_STORAGE_GET_DEVICE_NUMBER Error: %ld\n", GetLastError());

		(void)CloseHandle(hDevice);

		return (DWORD)-1;
	}

	//printf("%d %d %d\n\n", number.DeviceType, number.DeviceNumber, number.PartitionNumber);
	
	(void)CloseHandle(hDevice);
	
	return number.DeviceNumber;

}

/******************************************************************************

* Function: get disk's drive letters from physical number
获取一个物理硬盘上的所有盘符
*           e.g. 0-->{C, D, E} (disk0 has 3 drives, C:, D: and E:)

* input: vDiskNo, disk's physical number

* output: letters, letters array

* return: Succeed, the amount of letters

*         Fail, -1

******************************************************************************/

CString CMDiskManager::GetPartitionLetterFromPhysicalDrive(DWORD vDiskNo)
{
	DWORD mask;
	DWORD driveType;
	DWORD bmLetters;
	DWORD diskNumber;
	CHAR path[256];
	CHAR letter;
	DWORD letterNum;
	WORD i;
	CHAR *p;
	CString tRet = ""; 

	bmLetters = GetLogicalDrives();

	if (0 == bmLetters)
	{
		return "";
	}
	
	letterNum = 0;

	for (i = 0; i < sizeof(DWORD) * 8; i++)
	{
		mask = 0x1u << i;

		if ((mask & bmLetters) == 0)        //get one letter
		{
			continue;
		}

		letter = (CHAR)(0x41 + i);    //ASCII change

		sprintf(path, "%c:\\", letter);

		driveType = GetDriveType(path);

		if (driveType != DRIVE_FIXED)
		{
			bmLetters &= ~mask;     //clear this bit
			continue;
		}

		diskNumber = GetPhysicalDriveFromPartitionLetter(letter);

		if (diskNumber != vDiskNo)
		{
			bmLetters &= ~mask;     //clear this bit

			continue;
		}

		letterNum++;
	}
	
	//build the result

	/*letters = (CHAR *)malloc(letterNum);
	
	if (NULL == *letters)
	{
		return (DWORD)-1;
	}

	p = *letters;
	*/
	CString s;
	for (i = 0; i < sizeof(DWORD) * 8; i++)
	{
		mask = 0x1u << i;

		if ((mask & bmLetters) == 0)
		{
			continue;
		}

		letter = (CHAR)(0x41 + i);    //ASCII change
		s.Format("%c", letter); 
		if (!tRet.IsEmpty()){
			tRet +=  ",";
		}
		tRet += s + ":"; 
		
	}

	return tRet;
}


 

 
 

 
 
头文件：CMDiskManager.h
 
#include <windows.h>
#include <winioctl.h>
#include <stdio.h>
#include "time.h"

#include <stdlib.h>
#include <tchar.h>

#pragma pack(1)

#define MAX_MBR_PARTITIONS          4
#define MBR_DISK_SIGNATURE_OFFSET   440
#define MBR_DISK_PPT_OFFSET         446
#define MBR_SIGNATURE_OFFSET        510

//
// MBR Partition Entry
//
typedef struct {
	UINT8  BootIndicator;
	UINT8  StartHead;
	UINT8  StartSector;
	UINT8  StartTrack;
	UINT8  OSType;
	UINT8  EndHead;
	UINT8  EndSector;
	UINT8  EndTrack;
	UINT32 StartingLBA;
	UINT32 SizeInLBA;
} MBR_PARTITION_RECORD;

//
// MBR Partition table
//
typedef struct {
	UINT8                 BootCode[440];
	UINT32                UniqueMbrSignature;
	UINT16                Unknown;
	MBR_PARTITION_RECORD  PartitionRecord[MAX_MBR_PARTITIONS];
	UINT16                Signature;
} MASTER_BOOT_RECORD;

#pragma pack()

#define MBR_SIGNATURE               0xAA55
#define EXTENDED_DOS_PARTITION      0x05
#define EXTENDED_WINDOWS_PARTITION  0x0F


class CMDiskManager {

public:

	CMDiskManager(); 

	//获取磁盘几何
	BOOL GetDriveGeometry(DWORD vDiskNo, DISK_GEOMETRY *pdg);
	 
	//获取磁盘大小,单位是MB
	int GetDiskSize(DWORD vDiskNo);

	/*
	获取磁盘分区信息
	vDiskNo:磁盘序号 
	*/
	DWORD GetLayoutInfo(DWORD vDiskNo);

	//读MBR信息
	BOOL ReadMBR(int vDiskNo, LPVOID *pBuffer);

	/*
	获取磁盘分区个数
	vDiskNo:磁盘序号
	*/
	int GetPartNum(DWORD vDiskNo);

	/*
	初始化磁盘，创建分区
	vDiskNo:磁盘序号，千万要避开系统盘，系统盘一般是0
	vPartNum:分区数，只要1个分区就可以了
	*/
	DWORD CreateDisk(DWORD vDiskNo, WORD vPartNum);

	/*
	回复磁盘到空白状态，删除MBR分区信息
	*/
	DWORD DestroyDisk(DWORD vDiskNo);

}; 

 如果CreateDisk之后文件系统格式还是RAW的，那么可以用这个：
/******************************************************************************
* Function:快速格式化某个磁盘，文件系统NTFS
* input: disk, disk name
* output: N/A
* return: Succeed, 0
*         Fail, 1
******************************************************************************/
DWORD CMDiskManager::FormatVolume(CHAR letter)
{
	DWORD ret;
	CHAR cmd[64];
	sprintf(cmd, "format %c: /FS:NTFS /Q /Y", letter);
	ret = (DWORD)system(cmd);
	return ret;
}

 

 
 

 
 

 
 

 
 

 
 

 

 
Windows磁盘格式及分区
 
Windows磁盘
磁盘格式分类
优缺点
   
分区格式
目的
类型
   
磁盘分区类型
基本磁盘
动态磁盘
动态磁盘卷分类
    
区别
  
 

 
Windows磁盘
 
磁盘格式分类
 
    Windows下磁盘格式主要有FAT16、FAT32、NTFS等，还有最新的exFAT,不同的磁盘格式有不同的特性。
 
FAT16 ，支持最大分区2GB，单文件最大2GB；
FAT32 ，支持最大分区124.55GB（scandisk），单文件最大4GB；
NTFS，支持最大分区2TB，单文件最大2TB；
exFAT ，也称FAT64；一种适合闪存的文件系统，单文件最大16EB（1EB=1024TB，1TB=1024GB）簇大小可达32MB；
 
优缺点
 
1.FAT32文件系统
 优点： 在不超过8GB的分区容量下，每个簇的容量都固定为4KB，与FAT16相比，可以大大减少磁盘的浪费，提高磁盘利用率。
 缺点： 由于分配表的扩大，运行速度比采用FAT16格式分区要慢，单个文件最大只能4GB。
 2.NTFS文件系统
 优点： 具有极高的安全性和稳定性，不易产生文件碎片，能对用户操作进行记录，对用户权限进行严格限制。突破了FAT32的单文件4GB限制。
 缺点： 只针对机械硬盘，对新兴Flash闪存不一定适合，采用日志式文件系统，因为记录磁盘的详细读写操作，对闪存介质会造成较大的负担，更容易损坏硬盘，对400MB一下的分区也比FAT16更浪费空间。
 3.exFAT文件系统
 优点： 突破FAT32的单文件最大4GB的限制，簇大小非常灵活，最小0.5KB，最高32MB，空间利用率高，支持访问控制。
 缺点： 闪存专用，U盘和存储卡才能格式化为exFAT，兼容性不好。
 
分区格式
 
目的
 
    允许在一个磁盘上有多个文件系统，有利于管理。
 
类型
 
1.MBR分区
     通常，我们将包含MBR引导代码的扇区称为主引导扇区（也称MBR扇区，简称MBR），它不属于任何分区，在磁盘中起管理磁盘空间的作用，负责磁盘操作系统DOS对磁盘进行读写时的合法性判断，分区引导信息的定位，只支持2TB以下的硬盘，超过2TB只管理2TB，最多支持四个分区，超过四个分区就要进行逻辑分区。
 2. GPT分区
     一种由基于Itanium计算机中的可扩展固件接口（EFI）使用的磁盘分区建构。与MBR相比，GPT允许每个磁盘多达128个分区，支持最高18EB的卷大小，允许将主分区表和备份磁盘分区表用于冗余。
 
磁盘分区类型
 
基本磁盘
 
    基本磁盘使用主分区、扩展分区和逻辑驱动器组织数据。格式化的分区也称为卷（术语“卷”和“分区”通常互换使用）。在此 Windows 版本中，基本磁盘可以有四个主分区或三个主分区和一个扩展分区。扩展分区可以包含无数个逻辑驱动器。基本磁盘上的分区不能与其他分区共享或拆分数据。基本磁盘上的每个分区都是该磁盘上一个独立的实体。基本磁盘是包含主分区、扩展分区或逻辑驱动器的物理磁盘。基本磁盘上的分区和逻辑驱动器称为基本卷。只能在基本磁盘上创建基本卷。
 分区形式：
     可在基本磁盘上创建的分区个数取决于磁盘的分区形式：
 
对于主启动记录 (MBR) 磁盘，可以最多创建四个主分区，或最多三个主分区加上一个扩展分区。在扩展分区内，可以创建多个逻辑驱动器。
对于 GUID 分区表 (GPT) 磁盘，最多可创建 128 个主分区。由于 GPT 磁盘并不限制四个分区，因而不必创建扩展分区或逻辑驱动器。
     可以向现有的主分区和逻辑驱动器添加更多空间，方法是在同一磁盘上将原有的主分区和逻辑驱动器扩展到邻近的连续未分配空间。要扩展基本卷，必须使用 NTFS 文件系统将其格式化。可以在包含连续可用空间的扩展分区内扩展逻辑驱动器。如果要扩展的逻辑驱动器大小超过了扩展分区内的可用空间大小，只要存在足够的连续未分配空间，扩展分区就会增大直到能够包含逻辑驱动器的大小。
 
动态磁盘
 
    动态磁盘可以包含无数个“动态卷”，其功能与基本磁盘上使用的主分区的功能相似。基本磁盘和动态磁盘之间的主要区别在于动态磁盘可以在计算机上的两个或多个动态硬盘之间拆分或共享数据。例如，一个动态卷实际上可以由两个单独的硬盘上的存储空间组成。另外，动态磁盘可以在两个或多个硬盘之间复制数据以防止单个磁盘出现故障。此功能需要更多硬盘，但提高了可靠性。
 基本磁盘在支持的系统内可使用Windows磁盘管理工具直接转换为动态磁盘，转换方便。
     但动态磁盘转换为基本磁盘在Windows磁盘管理中不能直接转换为基本磁盘，因动态磁盘是属性优于基本磁盘的属性，转换不可逆。
     动态磁盘要转换基本磁盘可删除所有动态磁盘卷后重新新建分区会默认为基本磁盘，但若磁盘内有数据的情况下以上方式明显不适用，可用一些三方分区软件转换，前提是自己找的软件中能不影响数据转换磁盘格式并且能识别出自己的硬盘分区。
 
动态磁盘卷分类
 
1、简单卷（Simple Volume）：与基本磁盘的分区类似，只是其空间可以扩展到非连续的空间上。
 2、跨区卷（Spanned Volume）：可以将多个磁盘（至少2个，最多32个）上的未分配空间合成一个逻辑卷。使用时先写满一部分空间再写入下一部分空间。
 3、带区卷（Striped Volume）：又称条带卷RAID 0,将2~32个磁盘空间上容量相同的空间组成一个卷，写入时将数据分成64KB大小相同的数据块，同时写入卷的每个磁盘成员的空间上。带区卷提供最好的磁盘访问性能，但是带区卷不能被扩展或镜像，并且不提供容错功能。
 4、镜像卷（Mirrored Volume）：又称RAID 1技术，是将两个磁盘上相同尺寸的空间建立为镜像，有容错功能，但空间利用率只有50%，实现成本相对较高。
 5、带奇偶校验的带区卷：采用RAID 5技术，每个独立磁盘进行条带化分割、条带区奇偶校验，校验数据平均分布在每块硬盘上。其容错性能好，应用广泛，需要3个以上磁盘，平均实现成本低于镜像卷。
 
区别
 
一、更改磁盘容量
 
基本磁盘分区一旦创建就无法更改磁盘容量大小。
动态磁盘在不重新启动的情况下可以更改磁盘容量大小。
 
二、卷集或分区个数
 
动态磁盘在一个磁盘上可以创建多个卷数。
基本磁盘一个磁盘只能创建四个分区，而且使用DOS 或 Windeows 9x 只能分一个主分区和扩展分区。
 
三、磁盘空间
 
动态磁盘可以被扩展到磁盘中包括不连续的磁盘空间，可创建跨物理的卷。
基本磁盘必须是同一磁盘上的连续的空间才可分为一个区，分区最大的容量也就是磁盘的容量。
 四、磁盘配置信息
动态磁盘磁盘配置信息存放在磁盘上的可以移动到其他计算机上继续使用。
基本磁盘磁盘配置信息存放在磁盘引导分区中，RAID 磁盘移动到其他计算机上会丢失信息。

1、磁盘分区
 
（1）易于管理和使用：
 
比如说我们把磁盘分了sda1、sda2、sda3、sda4盘，我们假设sda1盘为系统盘，其他的比如说游戏、办公、软件盘，这样我们要重新分哪个区就直接在对应的盘分就可以了，不需要整块磁盘进行分区。根据用途我们也能较快的去使用相应的磁盘。
 
（2）有利于数据的安全：
 
通过分区可以降低数据损失的风险。出现硬盘坏道、错误操作、重装系统都有可能造成数据损失，如果分区了，那么我们就可以将损失最小化。
 
（3）节约寻找文件的时间：
 
这个我觉得跟第一条比较像，但是这里所说的寻找文件的时间，是指电脑搜索文件的时间。分区以后，电脑搜索文件时只需要在相对应的分区搜索就可以了，没必要进行全盘搜索。大大节省了寻找文件的时间。
 
一个扇区是512字节，其中有64个字节存储的是分区表，一条分区信息占16个字节，因此磁盘最多只能分四个分区，要想有多个分区怎么办？这时候就有了扩展分区。
 
扩展分区可以被继续划分为多个逻辑分区，逻辑分区是可以进行格式化的。扩展分区把逻辑分区的分区信息在扩展分区中找了一个位置给存起来。假如说p4扩展分区划分了三个逻辑分区那么第1个逻辑分区命名为sda5、第2个为sda6、第3个sda7，以此类推。一个磁盘被分为四个分区，第四个分区被设置为扩展分区，第一个逻辑分区为sda5。但是当整个磁盘被分为3个分区的时候，我们把扩展分区划分的第1个逻辑分区依然命名为sda5，而不是其它的。总结一下，就是不论磁盘有几个主分区，第一个逻辑分区一定是从sda5开始。
 
Linux系统有一个理念：“一切皆文件”，所以计算机的硬件在linux中也是以“文件”的形式存在于/dev目录中。
 
 
比如，光驱对应的文件是/dev/cdrom，CPU对应的文件是/dev/cpu。而硬盘对应的是/dev/sd*。第一块硬盘是/dev/sda，第二块磁盘是/dev/sdb。
 
但是一个磁盘通常又被分成多个分区，所以在磁盘文件的后面加上分区的序号来对应这个分区。参考下面的表格中的例子　　　
 　　
 
输入命令#fdisk /dev/sdb
 
 
输入p 查看当前硬盘分区，目前没有分区。
 
 
新建分区
 
 
查看新建扇区，以上新建了两个主分区，大小都是500M
 
 
修改分区类型
 

 
 
注意：sdb1：存放的是与系统相关的文件
 　　　　sdb2：虚拟内存交换分区
 　　　　start、end表示分区开始的扇区位置和结束的扇区位置。
 　　　　blocks：表示块的信息，一个块里面有多个扇区。
 　　　　Id：表示磁盘类型编号
 　　　　system：表示Linux系统分区的一个分区信息。
 
此时不要着急，我们一定要记住要保存，在命令行输入w保存分区信息。我们通过w保存并退出后，使用fdisk -l　　可以查看到磁盘的分区信息。
 　　但是当你在格式化的时候，有可能找不到这个分区。这是因为Linux没有把分区信息读到内核来，我们需要输入partprobe这个命令，来使我们内核重读一下我们的分区信息。
 
2.格式化
 
命令：mke2fs mke2fs [选项] 文件系统 磁盘盘符=
 
注释：
 1、磁盘虽然分好区了，但是还不能用，还需要在这每一个分区上格式化，所谓格式化，其实就是安装文件系统，Windows下的文件系统有Fat32、NTFS，CentOS使用的文件系统为ext，之前centOS5版本使用ext3作为默认的文件系统，而CentOS6使用ext4作为默认的文件系统；
 2、当用man查询这四个命令的帮助文档时，你会发现我们看到了同一个帮助文档，这说明四个命令是一样的；
 3、指定文件系统格式为ext4，该命令等同于mkfs ext4 /dev/sdb5，以后我们遇到余姚格式磁盘分区的时候，直接指定格式化为ext4即可，也可以根据操作系统的版本来决定格式化什么格式；
 选项：
 
-b：分区时设定每个数据块占用空间大小，目前支持1024、2048以及4096 bytes每个块；
 
-i：设定inode的大小；
 
-N：设定inode数量，有时使用默认的inode数不够用，所以要自定设定inode数量；
 
-c：在格式化前先检测一下磁盘是否有问题，加上这个选项后会非常慢；
 
-L：预设该分区的标签label；
 
-j：建立ext3格式的分区，如果使用mkfs.ext3就不用加这个选项了；
 
-t：用来指定什么类型的文件系统，可以是ext2、ext3也可以是ext4；
 
-m：格式化时，指定预留给管理员的磁盘比例，是一个百分比，只针对mke2fs命令；
 
例如：mke2fs -t ext4 -b 4096 /dev/sdb5
 
注意：其中一个指标是“块的大小=4096”这里涉及到一个“块”的概念，磁盘在被格式化的时候会预先规定好每一个块的大小，然后再把所有的空间分割成一个一个的小块，存数据的时候也是一个快一个快的去写入，所以如果你的磁盘存的都是特别小特别小的文件，比如说1k或者2k，那么建议在格式化磁盘的时候指定块数值小一点，ext文件系统默认块的大小为4096，也就是4k，在格式化的时候，可以指定块大小为1024、2048或者4096（它们是成倍增加的），虽然格式化的时候可以指定块大小超过4096，但是一旦超过4096则不能正常挂载；
 
指定块的大小： mke2fs -t ext4 -b 8192 /dev/sdb5
 

 
 
 
注意：可以使用-L来指定标签，标签会在挂载磁盘的时候使用，另外也可以写到配置文件里，关于格式化的这一部分，我建议除非有需求，否则不需要指定块的大小，也就是说，你只需要记住这两个选项：-t和-L即可。
 
更多关于Linux磁盘格式化的基础分享：
 
基本功，格式化命令，以格式化 /dev/sda1 分区为例：
 $ sudo umount /dev/sda1
 
必须先卸载该分区
 
格式化为 FAT 分区
 
$ sudo mkfs.vfat -F 32 /dev/sda1 # -F 参数必须大写，参数有 12，16 和 32，分别对应 FAT12，FAT16，FAT32。
 
格式化为 NTFS 分区，先要安装ntfsprogs，以 Ubuntu / Debian 为例：
 
$ sudo apt-get install ntfsprogs
 
#然后执行格式化命令，以格式化 /dev/sda1 分区为例：
 $ sudo umount /dev/sda1 # 必须先卸载该分区
 $ sudo mkfs.ntfs /dev/sda1 # 格式化为ntfs速度有点慢。
 
格式化为ext4/3/2 ， 以格式化 /dev/sda1 分区为例：
 
$ sudo umount /dev/sda1 # 必须先卸载该分区
 $ sudo mkfs.ext4 /dev/sda1 # 格式化为ext4分区
 $ sudo mkfs.ext3 /dev/sda1 # 格式化为ext3分区
 $ sudo mkfs.ext2 /dev/sda1 # 格式化为ext2分区
 
由于ext系列的分区都有一个给super user的保留空间，必须占用一定的百分比，默认5%，这么一来格式化容量小的分区还不觉得，5%也没多少，但是如果是几百G，1T的分区就会有问题，in this case，5%可是不小的数目啊！
 
『解决方法』
 
一、针对将要格式化的分区，以ext3为例：
 $ sudo umount /dev/sda1 # 必须先卸载该分区，这里要格式化的是 /dev/sda1 分区。
 $ sudo mkfs.ext3 -m 0.05 /dev/sda1 # 注意-m后的参数，设定的已经是百分位，这里设定为0.05，是0.05%，也就是万分之5！
 
好了，这样以1T的分区为例，1T=1024GB=1048576MB（都是乘以1024的关系），1048576MB*0.0005=524.288MB。
 
也就是说设定-m参数之后，保留区大概是524MB。当然你可以根据自己喜好设定。
 
二、对已经格式化完毕的分区，并且不想擦出分区中的数据，可以使用tune2fs -m的方法：
 
这条命令无须先卸载分区。
 
$ sudo tune2fs -m 0.05 /dev/sda2 # 这个例子是转换 /dev/sda2 分区的super user保留区，同样设定为0.05，在提醒一次，是0.05%，也就是万分之5。
 
3. 挂载分区
 
提示：使用df -h命令可以查看当前系统中已经挂载的分区
 
3.1 手动挂载分区
 
1
 mount -t /dev/sdb1 /mnt/sdb1
 卸载分区umount命令格式：
 1
 umount [option] special | node
 使用umount卸载分区时，可以指定挂载点，也可以指定挂载的路径
 比如本例要卸载sdb1分区的挂载，则使用
 1
 umount /dev/sdb1或者umount /mnt/sdb1
 ps:使用umount卸载时，如果是指定的设备路径，则umount会按照按照挂载顺序去卸载分区最后被挂载的挂载点。
 
3.2 自动挂载分区
 
linux系统在启动时，会从/etc/fstab文件自动挂载分区。
 图中是一个fstab文件的示例。
 
 fstab中，每条配置信息都分为固定的6个部分
 [1]:分区路径，或者UUID
 [2]:fs_file - 该字段描述希望的文件系统加载的目录点，对于swap设备，该字段为none；对于加载目录名包含空格的情况，用40来表示空格。
 [3]:fs_type - 定义了该设备上的文件系统，一般常见的文件类型为ext4 (Linux设备的常用文件类型)、vfat(Windows系统的fat32格式)、NTFS、isoArray600等。在不确定的情况下可以使用auto。
 [4]:fs_options - 指定加载该设备的文件系统是需要使用的特定参数选项，多个参数是由逗号分隔开来。
 对于大多数系统使用"defaults"就可以满足需要。不多说。
 [5]:fs_dump - 该选项被"dump"命令使用来检查一个文件系统应该以多快频率进行转储，若不需要转储就设
 置该字段为0
 [6]:fs_pass - 该字段被fsck命令用来决定在启动时需要被扫描的文件系统的顺序，根文件系统"/"对应该字
 段的值应该为1，其他文件系统应该为2。若该文件系统无需在启动时扫描则设置该字段为0
 
本例，在fstab文件中添加sdb1分区自动挂载的配置如下：
 1 /dev/sdb1 /mnt/sdb1 ext4 defaults 0 2
 ps：其它账户（如orac、mysql）在使用这个新的分区时，可能会遇到权限不足的问题，使用以下命令解决
 1 chmod 777 /mnt/sdb1

相信大家对Windows分区应该都不陌生，今天写的这篇文章是在Ubuntu系统用命令行模式对硬盘进行操作。如果遇到不明白的知识点可以参照《鸟哥的Linux私房菜》里面有详细的说明，写这篇文章的目的是为了巩固所学并锻炼自己的写作能力。
 
废话不多说，直接上正文。
 
使用如下命令查看系统内所有磁盘的基本信息。
 
 ls -al /dev/sd*
 
 
我是用virtualbox虚拟机添加了一块40G硬盘，查看一下硬盘的具体信息，从而确定哪一块是新添加的硬盘。
 
用fdisk -l命令查看硬盘的具体信息。fdisk命令只有root用户才能调用，临时调用需要加上sudo，即命令为：
 

sudo fdisk -l
 
（如果有一定基础的话上面一步可以省略）这里只截取有用的部分信息。
 
 
根据截图信息可以看出/dev/sdb是新添加的硬盘，然后再对其进行操作。
 
这是一块新硬盘要先分区然后格式化，执行以下命令
 
sudo fdisk /dev/sdb
 
使用 fdisk 命令是对整块磁盘进行分区操作，所以 sdb 后面不能加数字
 

wu@wu-ThinkPad-T510:~$ sudo fdisk /dev/sdb
[sudo] wu 的密码：

欢迎使用 fdisk (util-linux 2.31.1)。
更改将停留在内存中，直到您决定将更改写入磁盘。
使用写入命令前请三思。


命令(输入 m 获取帮助)：m

帮助：

  DOS (MBR)
   a   开关 可启动 标志
   b   编辑嵌套的 BSD 磁盘标签
   c   开关 dos 兼容性标志

  常规
   d   删除分区
   F   列出未分区的空闲区
   l   列出已知分区类型
   n   添加新分区
   p   打印分区表
   t   更改分区类型
   v   检查分区表
   i   打印某个分区的相关信息

  杂项
   m   打印此菜单
   u   更改 显示/记录 单位
   x   更多功能(仅限专业人员)

  脚本
   I   从 sfdisk 脚本文件加载磁盘布局
   O   将磁盘布局转储为 sfdisk 脚本文件

  保存并退出
   w   将分区表写入磁盘并退出
   q   退出而不保存更改

  新建空磁盘标签
   g   新建一份 GPT 分区表
   G   新建一份空 GPT (IRIX) 分区表
   o   新建一份的空 DOS 分区表
   s   新建一份空 Sun 分区表

 
输入m键获取帮助信息。
 
 输入n参数创建新的分区
 
 有关主分区，扩展分区，逻辑分区的知识参考《鸟哥的Linux私房菜》。这里分区采用的是一个主分区+扩展分区，再由扩展分区分为两个逻辑分区。
 

 中途输入错误需要删除分区，只需要输入根据提示输入d即可。如图：
 

 查看分区信息输入p，如图：
 

 逻辑分区默认编号从5开始，1-4留给主分区使用。
 

 最后输入w保存退出即可，如果不想保存输入q即可不保存退出。至此分区完成，下面进行格式化操作。
 
sudo mkfs.ext3 /dev/sdb1 
 
如果不知道参数的话输入mkfs后按两下 TAB 键（大写锁定上面的键），即可进行提示。
 
以此类推其他的分区重复以上操作就完成格式化，系统就可以识别了。下一步就写磁盘的挂载了。