精华内容
下载资源
问答
  • windows下初始化格式化磁盘

    千次阅读 2016-10-21 11:38:29
    #include "stdafx.h" #include "CMDiskManager.h" ...获取磁盘分区信息 vDiskNo:磁盘序号 */ DWORD CMDiskManager::GetLayoutInfo(DWORD vDiskNo) { char diskPath[256]; //磁盘内部路径 //生成

    新买来的硬盘是未初始化的,以我的理解就是没有引导扇区的,通常是没有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磁盘格式、分区格式及类型

    千次阅读 2019-08-24 14:38:59
    Windows磁盘格式及分区Windows磁盘格式分类优缺点分区目的类型 Windows磁盘格式 分类 Windows下磁盘格式主要有FAT16、FAT32、NTFS等,还有最新的exFAT,不同的磁盘格式有不同的特性。 FAT16 ,支持最大分区2GB...

    Windows磁盘

    磁盘格式分类

        Windows下磁盘格式主要有FAT16、FAT32、NTFS等,还有最新的exFAT,不同的磁盘格式有不同的特性。

    1. FAT16 ,支持最大分区2GB,单文件最大2GB;
    2. FAT32 ,支持最大分区124.55GB(scandisk),单文件最大4GB;
    3. NTFS,支持最大分区2TB,单文件最大2TB;
    4. 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 版本中,基本磁盘可以有四个主分区或三个主分区和一个扩展分区。扩展分区可以包含无数个逻辑驱动器。基本磁盘上的分区不能与其他分区共享或拆分数据。基本磁盘上的每个分区都是该磁盘上一个独立的实体。基本磁盘是包含主分区、扩展分区或逻辑驱动器的物理磁盘。基本磁盘上的分区和逻辑驱动器称为基本卷。只能在基本磁盘上创建基本卷。
    分区形式:
        可在基本磁盘上创建的分区个数取决于磁盘的分区形式:

    1. 对于主启动记录 (MBR) 磁盘,可以最多创建四个主分区,或最多三个主分区加上一个扩展分区。在扩展分区内,可以创建多个逻辑驱动器。
    2. 对于 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个以上磁盘,平均实现成本低于镜像卷。

    区别

    一、更改磁盘容量

    1. 基本磁盘分区一旦创建就无法更改磁盘容量大小。
    2. 动态磁盘在不重新启动的情况下可以更改磁盘容量大小。

    二、卷集或分区个数

    1. 动态磁盘在一个磁盘上可以创建多个卷数。
    2. 基本磁盘一个磁盘只能创建四个分区,而且使用DOS 或 Windeows 9x 只能分一个主分区和扩展分区。

    三、磁盘空间

    1. 动态磁盘可以被扩展到磁盘中包括不连续的磁盘空间,可创建跨物理的卷。
    2. 基本磁盘必须是同一磁盘上的连续的空间才可分为一个区,分区最大的容量也就是磁盘的容量。
      四、磁盘配置信息
    3. 动态磁盘磁盘配置信息存放在磁盘上的可以移动到其他计算机上继续使用。
    4. 基本磁盘磁盘配置信息存放在磁盘引导分区中,RAID 磁盘移动到其他计算机上会丢失信息。
    展开全文
  • 磁盘分区及格式化和挂载

    千次阅读 2020-05-21 08:41:36
    1、磁盘分区 ...出现硬盘坏道、错误操作、重装系统都有可能造成数据损失,如果分区了,那么我们就可以将损失最小。 (3)节约寻找文件的时间: 这个我觉得跟第一条比较像,但是这里所说的寻找文件的时间

    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私房菜》里面有详细的说明,写这篇文章的目的是为了巩固所学并锻炼...

    相信大家对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 键(大写锁定上面的键),即可进行提示。

    以此类推其他的分区重复以上操作就完成格式化,系统就可以识别了。下一步就写磁盘的挂载了。

    展开全文
  • 硬盘的分区和分区格式化类型详解

    千次阅读 2015-11-09 00:18:25
    分区从实质上说就是对硬盘的一种格式化。当我们创建分区时,就已经设置好了硬盘的各项物理参数,指定了硬盘主引导记录(即Master Boot Record,一般简称为MBR)和引导记录备份的存放位置。而对于文件系统以及其他操作...
  • 现在购买的U盘,价格便宜,种类多,但是质量也比较差,很多U盘用一段时间就会出现打不开,格式化失败,提示如“windows无法完成格式化”之类。但是这并不就是意味着U盘就此要废弃了,试一试如下的方法救回你的U盘: ...
  • linux学习——硬盘分区和格式化

    千次阅读 2018-12-04 17:08:39
    硬盘分区和格式化篇   1、磁盘分区 1.概念:磁盘分区是使用分区编辑器(partition editor)在磁盘上划分几个逻辑部分。碟片一旦划分成数个分区(Pratition),不同类的目录和文件可以存储进不同的分区。(分区...
  • 计算机硬盘格式化与储存原理

    千次阅读 2018-04-28 18:11:11
    在学Linux系统时听到关于格式化相关知识老师顺便讲解了关于硬盘的储存原理内容不算多主讲人: 沈超老师 李明老师系统分区也叫做磁盘分区通俗来说,就是将一个大的硬盘人为的分为几个较小的硬盘然后每个分区规定只能放...
  • 一、磁盘分区parted(支持单块硬盘大于2TB)(GPT分区标准) 二、格式化磁盘分区mkfs
  • linux文件系统及磁盘格式化

    千次阅读 2017-02-13 10:10:38
    此处将两种分区机制磁盘进行分区格式化(MBR类型磁盘——用fdisk###GPT类型磁盘——用parted)。fdisk不支持大于2T的分区寻址(后边再详细介绍原理,这里为保持简单不涉及)。 1> fdisk -l #查看当
  • 低级、高级格式化

    千次阅读 2018-08-29 13:18:36
    通常,格式化分为两种类型:低级格式化和高级格式化。如果没有特殊指令,则硬盘格式化通常是指高级格式化过程,而软盘格式化通常包括两种格式化类型。阅读以下内容以了解有关低级格式化和高级格式化的更多信息。  ...
  • Linux格式化硬盘

    千次阅读 2016-11-28 10:55:45
    格式化硬盘是指初始化硬盘的文件系统。文件储存在硬盘上,硬盘的最小存储单位叫做”扇区”(Sector)。每个扇区储存512字节(相当于0.5KB)。 linux上的常见的文件系统 ext2 ext3 ext4。1 inode每个文件对应一个...
  • 格式化分配单元大小In addition to asking for the file system you’d like to use, disk formatting tools will also ask for an “Allocation unit size”. What does this mean and what value should you ...
  • 硬盘接口类型 硬盘的接口主要有 IDE、SATA、SCSI、SAS 和光纤通道等五种类型。其中 IDE 和 SATA 接口硬盘多用于家用产品中,也有部分应用于服务器,SATA 是一种新生的硬盘接口类型,已经取代了大部分 IDE 接口应用。...
  • 格式化则是将分区好的硬盘,根据操作系统的安装格式需求进行格式化处理,以便在系统安装时,安装程序可以对硬盘进行访问。 2.1.1什么是硬盘分区 硬盘分区是指将硬盘分割为多个区域。以方便数据的存储与管理。...
  • windows无法完成格式化U盘与U盘修复几种解决方法 U盘由于种种不同的原因而格式化失败,提示如“windows无法完成格式化”之类。但是这并不就是意味着U盘就此要废弃了,试一试如下的方法(不过对于不长玩电脑的人...
  • 磁盘格式MBR和GPT

    千次阅读 2018-10-04 13:31:05
    MSDOS(MBR)和GPT–早期的Linux系统采用MBR的方式来处理开机引导程序和分区表,这些通常放在磁盘的第一个扇区(512字节)中,但是 MBR分区只能抓取2TB的容量等等的限制,新的分区格式GPT因此产生 一、MBR MBR位于...
  • OneDrive已经不允许FAT/FAT32磁盘文件进行同步备份等,但实际上微软在Win10创意者更新中已经彻底封杀了exFAT/FAT32磁盘,IT之家发现在Windows10最新版本系统中,格式化磁盘选项已经只剩下NTFS和REFS两种格式。...
  • 分区和格式化的概念

    2020-02-16 18:41:13
    简单来讲,分区就是将大块硬盘逻辑上分为小多个的硬盘。目的就是为了存取数据更加快捷方面,能够分门别类的存取。 二、分区的表现形式 1、MBR分区表:主引导记录分区表。最大支持2.1TB硬盘,每块硬盘最多支持4个...
  • Windows XP 下格式化和清理磁盘(转)[@more@]  格式化磁盘就是在磁盘内进行分割磁区,作内部磁区标示,以方便...格式化磁盘分为格式化硬盘格式化软盘两种。格式化硬盘又可分为高级格式化和低级格式化,高级格式...
  • 本文适用人群: 抱着学习的态度的人儿  格式化U盘不知道怎么选择格式的  想要用U盘作为Mac和Windows电脑传输文件的    U盘是我们现在最常用的一种存储设备,体积...不管是u盘还是硬盘都需要其进行格式化...
  • 硬盘格式化

    千次阅读 2014-03-17 02:04:57
     碰到了格式化的问题,DM,PQ,DOS-FDISK,SMART-FDISK等,还把姐夫的老电脑拿来搞,呵!^_^~~      电脑的数据和资料都是存储在硬盘着个设备上的,对于用户来说硬盘是很重要的一个“数据库”,如果这个设备出现故障...
  • linux初学之2——系统分区与格式化

    千次阅读 2016-02-26 16:01:09
    系统分区与格式化的概念,不只是windows特有的,也不是linux系统特有的,本篇讲的并非操作,不是讲怎样去分区怎样去格式化,而是讲分区与格式化的概念和意义。  1、系统分区  传统印象:windows系统,分为C盘、D盘...
  • 在这些情况下,您必须格式化U盘来修复损坏或变成RAW格式的U盘、SD卡以及外接式硬盘。 如果我格式化一个U盘,上面的数据会被清空吗? 你有没有这样的困惑:如果我格式化一个U盘,会删除存在U盘上的数据吗?格式化是...
  • 格式化原理

    千次阅读 2013-12-15 09:21:57
    低级格式化:低级格式化就是将空白的磁盘划分出柱面和磁道,再将磁道划分为若干个扇区,每个扇区又划分出标识部分ID、间隔区GAP和数据区DATA等。可见,低级格式化是高级格式化之前的一件工作,它只能够在DOS环境来...
  • 理论题 —— Windows 7基础知识

    千次阅读 2021-04-12 22:18:42
    1.关于Windows 7的启动,以下描述错误的是________。 答案:D A.启动Windows7操作系统时,可选择登录账户 B.用户账户的登录密码可在控制面板中设置 C.启动Window操作系统时,按F8可进入安全模式 D.用户账户登录时...
  • Android 格式化分区命令

    千次阅读 2017-04-12 18:13:01
    mkfs.vfat /dev/block/mmcblk0pxxxx busybox mkfs.vfat /dev/block/mmcblk...二,格式化磁盘分区:mkfs.xxx 三,挂载磁盘分区:mount、umount 四,文件系统管理:e2abel、blkid、tun2fs、df 五,开机自动挂载:/etc
  • 无法将windows server安装到磁盘0的分区(GPT分区) 服务器,4T硬盘,U盘安装Windows Server 2008 R2。 把2008的镜像用UltraISO写入U盘。 安装到分区那块,主分区200G,剩余分区系统自动给分为: 2T + 剩余 两块...
  • 高级格式化与低级格式化

    千次阅读 2014-12-12 14:28:33
    如果没有特别指明,对硬盘格式化通常是指高级格式化,而软盘的格式化则通常同时包括这两者。 格式化方法: 简单地说,格式化就是为磁盘做初始化的工作,以便我们能够按部就班地往磁盘上记录资料。好比我们有一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,995
精华内容 19,998
关键字:

windows7对磁盘格式化分为