【双硬盘双系统】LinuxC下对EFI格式windows磁盘进行分区-动态生成GPT表

最新推荐文章于 2023-01-16 10:50:47 发布
最新推荐文章于 2023-01-16 10:50:47 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： c语言编程基础 c语言编程算法 LinuxC 操作windows磁盘编程 分区表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/algolc/article/details/70050767
版权




动态生成GPT分区表

1. 题目具体要求描述
1) 在硬盘上安装win10 64位系统(GPT分区模式), 硬盘要预留空闲空间; --- 前置部署条件
2) 程序具体功能：
A. check 功能
   显示当前硬盘上的已划分空间和剩余空间，显示当前硬盘上的分区位置(起始扇区和结束扇区);
B. Add 功能
   在空闲空间上添加指定大小的分区;
C. Del 功能
   可以把指定(序号)分区从硬盘上删除掉;


2. 基于 linux 平台开发( 提供开发环境 && 基本的磁盘读写接口 && 简单的程序框架 );  



diskop.h

#ifndef _DISKOP_H_
#define _DISKOP_H_



#define DISK_READ 2
#define DISK_WRITE 3
#define RETRYTIMES_READWRITE 5

typedef u_int8_t  BYTE;
typedef u_int16_t WORD;
typedef u_int32_t DWORD;
typedef u_int64_t DDWORD;

typedef unsigned long long ULONGLONG;
typedef long long LONGLONG;
typedef unsigned long ULONG;
typedef BYTE* LPBYTE;
typedef DWORD UINT;
typedef WORD USHORT;
typedef BYTE* LPSTR;
typedef unsigned char TCHAR;
typedef long long __int64;
typedef WORD* LPWORD;
typedef BYTE BOOL;





int myreadorwrite(BYTE readorwrite, int fd, BYTE *buf, size_t size)
{
	size_t total_written = 0;
	ssize_t nwritten = 0;
	while(total_written < size)
	{
		//??д???
		if(readorwrite == DISK_WRITE)
			nwritten = write(fd, buf + total_written, size - total_written);
		else if(readorwrite == DISK_READ)
			nwritten = read(fd, buf + total_written, size - total_written);
		//?ж??д???
		if(nwritten > 0)
			total_written += nwritten;
		else if(nwritten == 0)
			break;
		else
			return -1;
	}
	return total_written;
}

/*
 * ===  FUNCTION  ======================================================================
 *         Name:  hd_4kblok_readwrite
 *  Description:  ???read/write???????????д???(????)???С???4kb.
 * =====================================================================================
 */
static DDWORD
hd_4kblok_readwrite (BYTE readorwrite,int fp_disk,DDWORD logsec,DDWORD blocksize, BYTE * buff)
{
		int local_adjust = 0;
		DDWORD relogsec = 0;
		DDWORD reblocksize = 0;
		DDWORD tmp_blockcount = 0;
		DDWORD total_size = 0;
		BYTE tmpbuffer[4096];
		int retry_lseek = 0;
		int n;
		int ret = 0;
		char str[300];
		DDWORD lseek_local = 0;


		local_adjust = logsec % 8;
		relogsec = logsec - local_adjust;

	
		//?????д?????λ??
		DDWORD size = (DDWORD)(relogsec * 512);
		retry_lseek = 0;
		while(retry_lseek < RETRYTIMES_READWRITE)
		{
				ret = lseek64(fp_disk, size, SEEK_SET);

				if(ret == -1)
				{
						retry_lseek ++;
						if(retry_lseek >= 3)//??3?ζ?λ????????????????
						{
								printf("readorwrite lseek error:%d, disk_fd:%d, relogsec:[%lu].\n", readorwrite, fp_disk, relogsec);
								printf("relogsec lseek error! user press cancel ... \n");
						}
				}
				else {
						break ;
				}

		}


		tmp_blockcount = blocksize + local_adjust;
		//		printmsg("tmp_blockcount = %lld\n", tmp_blockcount);
		reblocksize = ( tmp_blockcount/8 + 1 ) * 8;
		if ( tmp_blockcount % 8  == 0 ) {
				reblocksize -= 8;
		}

		if ( readorwrite == DISK_READ ) {

				n = 0;
				total_size = 0;

				if ( reblocksize / 8 == 1 ) {

						if ( read(fp_disk, tmpbuffer, 8 * 512) != 8 * 512 ) {
								printf("read type @ 1 read 4k block error :%s\n", strerror(errno));
								return -1;
						}

						memcpy(buff, tmpbuffer + local_adjust * 512, blocksize * 512);
						total_size = blocksize * 512;
				}
				else {
						while ( n < reblocksize / 8 ) {

								if ( read(fp_disk, tmpbuffer, 8 * 512) != 8 * 512 ) {
										printf("read type @ 2 read 4k block error :%s\n", strerror(errno));
										return -1;
								}
								n++;

								if ( n == 1 ) {

										memcpy(buff, tmpbuffer + local_adjust * 512, (8 - local_adjust) * 512);
										total_size += (8-local_adjust) * 512;
										buff += (8 - local_adjust) * 512;


								}
								else if ( n == reblocksize / 8 ) {
										if ( tmp_blockcount % 8 == 0 ) {
												memcpy(buff, tmpbuffer, 8 * 512);
												total_size += 8 *512;
										}
										else {
												memcpy(buff, tmpbuffer, tmp_blockcount % 8 * 512);
												total_size += tmp_blockcount % 8 * 512;
										}
								}
								else {
										memcpy(buff, tmpbuffer, 8 * 512);
										total_size += 8 * 512;
										buff += 8 * 512;


								}


						}
				}

		}
		else if ( readorwrite == DISK_WRITE ) {

				n = 0;
				total_size = 0;

				if ( reblocksize / 8 == 1 ) {

						retry_lseek = 0;
						while(retry_lseek < RETRYTIMES_READWRITE)
						{
								lseek_local = lseek64(fp_disk, 0, SEEK_CUR);

								if(lseek_local == -1)
								{
										retry_lseek ++;
										if(retry_lseek >= 3)//??3?ζ?λ????????????????
										{
												printf("seek curren 1 error: n:%d, errno:%s.\n",
																n, strerror(errno));
												printf("seek curren 1 error! user press cancel ... \n");
										}
								}
								else {
										break ;
								}

						}


						if ( read(fp_disk, tmpbuffer, 8 * 512) != 8 * 512 ) {
								printf("write type @ 1 read 4k block error :%s\n", strerror(errno));
								return -1;
						}

						memcpy(tmpbuffer + local_adjust * 512, buff, blocksize * 512);

						retry_lseek = 0;
						while(retry_lseek < RETRYTIMES_READWRITE)
						{
								ret = lseek64(fp_disk, lseek_local, SEEK_SET);

								if(ret == -1)
								{
										retry_lseek ++;
										if(retry_lseek >= 3)//??3?ζ?λ????????????????
										{
												//												printmsg("zfk relogsec = %lld.\n", relogsec);
												printf("readorwrite lseek error:%d, n:%d, lseek_local:[%lu], errno:%s.\n",
																readorwrite, n, lseek_local, strerror(errno));
												printf("write 3 lseek error! user press cancel ... \n");
										}
								}
								else {
										break ;
								}

						}


						if ( write(fp_disk, tmpbuffer, 8 * 512) != 8 * 512 ) {
								printf("write type @ 1 write 4k block error :%s\n", strerror(errno));
								return -1;
						}
						total_size = blocksize * 512;
				}
				else {
						while ( n < reblocksize / 8 ) {

								n++;

								if ( n == 1 ) {

										retry_lseek = 0;
										while(retry_lseek < RETRYTIMES_READWRITE)
										{
												lseek_local = lseek64(fp_disk, 0, SEEK_CUR);

												if(lseek_local == -1)
												{
														retry_lseek ++;
														if(retry_lseek >= 3)//??3?ζ?λ????????????????
														{
																printf("seek curren 2 error: n:%d, errno:%s.\n",
																				n, strerror(errno));

																printf("seek curren 2 error! user press ok ... \n");
														}
												}
												else {
														break ;
												}

										}


										if ( read(fp_disk, tmpbuffer, 8 * 512) != 8 * 512 ) {
												printf("write type @ 2 read 4k block error :%s\n", strerror(errno));
												return -1;
										}

										memcpy(tmpbuffer + local_adjust * 512, buff, (8 - local_adjust) * 512);

										retry_lseek = 0;
										while(retry_lseek < RETRYTIMES_READWRITE)
										{
												ret = lseek64(fp_disk, lseek_local, SEEK_SET);

												if(ret == -1)
												{
														retry_lseek ++;
														if(retry_lseek >= 3)//??3?ζ?λ????????????????
														{
																//												printmsg("zfk relogsec = %lld.\n", relogsec);
																printf("readorwrite lseek error:%d, n:%d, lseek_local:[%lu], errno:%s.\n",
																				readorwrite, n, lseek_local, strerror(errno));

																printf("write 4 lseek error! user press ok ... \n");
														}
												}
												else {
														break ;
												}

										}


										if ( write(fp_disk, tmpbuffer, 8 * 512) != 8 * 512 ) {
												printf("write type @ 2 write 4k block error :%s\n", strerror(errno));
												return -1;
										}

										total_size += (8-local_adjust) * 512;
										buff += (8 - local_adjust) * 512;


								}
								else if ( n == reblocksize / 8 ) {
										if ( tmp_blockcount % 8 == 0 ) {
												if ( write(fp_disk, buff, 8 * 512) != 8 * 512 ) {
														printf("write type @ 3 write 4k block error :%s\n", strerror(errno));
														return -1;
												}
												total_size += 8 *512;
										}
										else {

												retry_lseek = 0;
												while(retry_lseek < RETRYTIMES_READWRITE)
												{
														lseek_local = lseek64(fp_disk, 0, SEEK_CUR);

														if(lseek_local == -1)
														{
																retry_lseek ++;
																if(retry_lseek >= 3)//??3?ζ?λ????????????????
																{
																		printf("seek curren 3 error: n:%d, errno:%s.\n",
																						n, strerror(errno));

																		printf("seek curren 3 error! user press cancel ... \n");
																}
														}
														else {
																break ;
														}

												}

												if ( read(fp_disk, tmpbuffer, 8 * 512) == -1 ) {
														printf("write type @ 3 read 4k block error :%s\n", strerror(errno));
														return -1;
												}

												memcpy(tmpbuffer, buff, tmp_blockcount % 8 * 512);

												retry_lseek = 0;
												while(retry_lseek < RETRYTIMES_READWRITE)
												{
														ret = lseek64(fp_disk, lseek_local, SEEK_SET);

														if(ret == -1)
														{
																retry_lseek ++;
																if(retry_lseek >= 3)//??3?ζ?λ????????????????
																{
																		//												printmsg("zfk relogsec = %lld.\n", relogsec);
																		printf("readorwrite lseek error:%d, n:%d, lseek_local:[%lu], errno:%s.\n",
																						readorwrite, n, lseek_local, strerror(errno));
																		
																		printf("write 5 lseek error! user press cancel ... \n");
																}
														}
														else {
																break ;
														}

												}


												if ( write(fp_disk, tmpbuffer, 8 * 512) == -1 ) {
														printf("write type @ 4 write 4k block error :%s\n", strerror(errno));
														return -1;
												}

												total_size += tmp_blockcount % 8 *512;
										}
								}
								else {
										if ( write(fp_disk, buff, 8 * 512) != 8 * 512 ) {
												printf("write type @ 5 write 4k block error :%s\n", strerror(errno));
												return -1;
										}
										total_size += 8 *512;
										buff += 8 * 512;



								}


						}
				}


		}
		else {
				printf("read write type error!\n");
		}

		return total_size;
}		/* -----  end of function hd_4kblok_readwrite  ----- */
//??д????????????????д5??
WORD readwriteblocktohd(BYTE readorwrite,int fp_disk,DDWORD logsec,DDWORD blocksize, BYTE * buff)
{
		int readwritenbyte = 0;
		//	int ret = 0;
		char str[300];
		int retry = 0;
		//	int retry_lseek = 0;

	
	
		while(retry < RETRYTIMES_READWRITE)
		{
				readwritenbyte = hd_4kblok_readwrite(readorwrite, fp_disk, logsec, blocksize, buff);

				if ( readwritenbyte == -2 )
						return 1;
				//??д????????
				if(readwritenbyte == blocksize*512)
						return 0;
				//?????д???????????????
				printf("Disk read write error sector:%ld, retrytime:%d.\n", logsec, retry);
				retry++;
				if (retry >= 3) //?????3?ζ?д???????????????????
				{
						printf("read or write disk error !user press cancel ... \n");
				}
		}
		return 1;
}


DWORD mCrcTable[256];
DWORD ReverseBits(DWORD  Value)
{
  DDWORD   Index;
  DWORD    NewValue;
  NewValue = 0;
  for (Index=0;Index<32;Index++)
  {
    if ((Value & (1 << Index)) != 0)
    {
      NewValue = NewValue | (1 << (31 - Index));
    }
  }
  return NewValue;
}

void InitializeCrc32Table()
{
  DDWORD   TableEntry;
  DDWORD   Index;
  DWORD    Value;

  for(TableEntry=0;TableEntry<256;TableEntry++)
  {
    Value = ReverseBits((DWORD)TableEntry);
    for(Index=0;Index<8;Index++)
    {
      if ((Value & 0x80000000) != 0)
      {
        Value = (Value << 1) ^ 0x04c11db7;
      }
      else
      {
        Value = Value << 1;
      }
    }
    mCrcTable[TableEntry] = ReverseBits(Value);
  }
}

int CalculateCrc32 (void *Data, DDWORD DataSize,DWORD *CrcOut)
{
  DWORD    Crc;
  DDWORD   Index;
  BYTE     *Ptr = NULL;
  if(Data == NULL || DataSize == 0 || CrcOut == NULL)
    return 1;
  Ptr = (BYTE *)Data;
  Crc = 0xffffffff;
  for(Index=0;Index<DataSize;Index++)
  {
    Crc = (Crc >> 8) ^ mCrcTable[(BYTE) Crc ^ *Ptr];
    Ptr++;
  }
  *CrcOut = Crc ^ 0xffffffff;
  return 0;
}



#endif



gpt_op.c 

#define SIMPLE_CHINESE
#define _LARGEFILE64_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <ctype.h>
#include <linux/hdreg.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <linux/fs.h>
#include <uuid/uuid.h>
#include "diskop.h"

#pragma pack(4)
struct gpthead
{
	BYTE   Signature[8];
	DWORD  Revision;
	DWORD  HeaderSize;
	DWORD  HeaderCRC32;
	DWORD  Reserved;
	DDWORD MyLBA;
	DDWORD AlternateLBA;
	DDWORD FirstUsableLBA;
	DDWORD LastUsableLBA;
	BYTE   DiskGUID[16];
	DDWORD PartitionEntryLBA;
	DWORD  NumberOfPartitionEntries;
	DWORD  SizeOfPartitionEntry;
	DWORD  PartitionEntryArrayCRC32;
	BYTE   Other[512-92];//保留区
}head;

struct gptpartition
{
	BYTE   PartitionTypeGUID[16];
	BYTE   UniquePartitionGUID[16];
	DDWORD StartingLBA;
	DDWORD EndingLBA;
	BYTE   Attributes[8];
	BYTE   PartitionName[72];
	//BYTE Reserved[];
}GPT[128];//128个gpt分区表
#pragma pack()

int read_gpthead()
{
	int fd;
	int i=0;
	WORD ret=0;
	fd=open("/dev/sda", O_RDONLY);
	if(fd<0)
	{
		printf("open dev error\n");
		return -1;
	}
	
	ret=readwriteblocktohd(DISK_READ,fd,1,1,(BYTE*)&head);
	if(ret)
	{
		printf("read patition 2-23 error\n");
		return -1;
	}
	close(fd);
}

int read_table()
{
	int fd;
	WORD ret=0;

	fd=open("/dev/sda", O_RDONLY);
	if(fd<0)
	{
		printf("open dev error\n");
		return -1;
	}
	
	ret=readwriteblocktohd(DISK_READ,fd,2,32,(BYTE*)&GPT);
	if(ret)
	{
		printf("read patition 2-23 error\n");
		return -1;
	}
	close(fd);	
}

void show_table()
{
	WORD count=0;
	DDWORD gptsize=0;
	DDWORD gptstart=0;
	DDWORD gptend=0;
	read_table();

	printf("当前分区表信息如下：\n");
	for(int i=0; i<128; i++)
	{	
		if(GPT[i].EndingLBA==0 && GPT[i].StartingLBA==0)
			continue;

		gptend=ReverseBitsDD(GPT[i].EndingLBA);
		gptstart=ReverseBitsDD(GPT[i].StartingLBA);
		gptsize=gptend-gptstart;

		printf("GPT%d:\n",count);
		printf("gptstart:%08lx    \ngptend:  %08lx    \ngptsize:%09lx=%ldMB\n",gptstart,gptend,gptsize+1,(gptsize+1)*512>>20);

		count++;
		printf("\n");
	}
}

int check()
{
	int fd;
	WORD ret=0;
    DDWORD allsize=0;
	DDWORD alluse=0;
	DDWORD allnotuse=0;
	DDWORD gptsize=0;
	DDWORD gptstart=0;
	DDWORD gptend=0;
	BYTE buff[512]={0};

	system("clear");
	fd = open("/dev/sda", O_RDONLY);
     if (fd < 0)
     {
 		printf("open dev error\n");
 		return 0;
     }
     
    ioctl(fd, BLKGETSIZE, &allsize);
    
	allsize=allsize<<9;

	read_table(); //读取gpt分区表
	close(fd);
	
	for(int i=0; i<128; i++)
	{
		gptend=ReverseBitsDD(GPT[i].EndingLBA);
		gptstart=ReverseBitsDD(GPT[i].StartingLBA);
		gptsize=gptend-gptstart;
	
		if(gptend!=0 && gptstart!=0 && gptsize!=0)
		{	
			printf("GPT%d:  gptstart:%08lx    gptend:%08lx    gptsize:%016ldbyte= %ldMB\n\n",i,gptstart,gptend,(gptsize+1)*512,(gptsize+1)*512>>20);
			alluse=alluse+gptsize;
		}
	}
	
	//显示信息	
	allnotuse=allsize-(alluse<<9);
	printf("allsize=%lx %ldbyte= %ldKB= %ldMB= %ldGB\n",allsize>>9,allsize,allsize>>10,allsize>>20,allsize>>30);
	printf("alluse=%ldbyte= %ldKB= %ldMB= %ldGB\n",alluse<<9,alluse<<9>>10,alluse<<9>>20,alluse<<9>>30);
	printf("allnotuse=%ldbyte= %ldKB= %ldMB= %ldGB\n\n",allnotuse,allnotuse>>10,allnotuse>>20,allnotuse>>30);
}

int del()
{
	int fd=0;
	int ret=0;
	int tag=0;
	int count=0;

	BYTE buff[512]={0};

	DWORD senderCRC32_0;

	
	read_gpthead();//读取gpt头的信息
	show_table();//显示当前信息

	printf("delete num:");
	scanf("%d", &tag);
	
	for(int i=0; i<128; i++)//找到要删除的分区表
	{
		if(GPT[i].StartingLBA==GPT[tag].StartingLBA&&GPT[i].EndingLBA==GPT[tag].EndingLBA)
		{
			count = i;
			break;
		}
	}
	
	for(int i=count; i<(127-count); i++)//将要删除分区表后面的128个字节的分区表前移
	{
		memcpy((BYTE*)&GPT[i],(BYTE*)&GPT[i+1],128);		
	}
	
//最后一个数组清0
	memset((BYTE*)&GPT[127],0,128);
	
	
//写入备份分区
	fd = open("/dev/sda", O_RDWR);
     if (fd < 0)
     {
 		printf("open dev error\n");
 		return 0;
     }
	
	ret=readwriteblocktohd(DISK_WRITE,fd,head.AlternateLBA-32,32,(BYTE*)&GPT);
	if(ret)
	{
		printf("write  sector error\n");
		return -1;
	}
	ret=readwriteblocktohd(DISK_WRITE,fd,head.PartitionEntryLBA,32,(BYTE*)&GPT);
	if(ret)
	{
		printf("write  sector error\n");
		return -1;
	}

	//===========计算出CRC32后写入gpt头和备份区
	
	senderCRC32_0=0;
	InitializeCrc32Table();
	ret = CalculateCrc32((void *)&GPT,128*128,&senderCRC32_0);
     if(ret)
     {
          printf("cal the sender backup CRC32_0 error\n");
                    
          return 0;
     }
	printf("%x \n",senderCRC32_0);
	
//=====		
	
	ret=readwriteblocktohd(DISK_READ,fd,head.MyLBA,1,(BYTE*)&head);
	if(ret)
	{
		printf("read error\n");
		return -1;
	}
	head.PartitionEntryArrayCRC32=ReverseBitsD(senderCRC32_0);
	head.HeaderCRC32=0;
	printf("aaaa%x \n",head.PartitionEntryArrayCRC32);

	ret = CalculateCrc32((void *)&head,head.HeaderSize,&senderCRC32_0);
     if(ret)
     {
          printf("cal the sender backup CRC32_0 error\n");              
          return 0;
     }
	printf("%x \n",senderCRC32_0);
	
//=============
	head.HeaderCRC32=ReverseBitsD(senderCRC32_0);

//=========写入gpt备份区

	ret = readwriteblocktohd(DISK_WRITE,fd,head.AlternateLBA,1, (BYTE*)&head);
     if(ret)
     {
     	printf("read/write error%d\n",ret);
     }
//=========写入gpt头
	ret = readwriteblocktohd(DISK_WRITE,fd,head.MyLBA,1, (BYTE*)&head);
     if(ret)
     {
     	printf("read/write error%d\n",ret);
     }
	close(fd);
//============

	show_table();

}

int add()
{
	int fd=0;
	int ret=0;
	int count=0;
	BYTE _PartitionTypeGUID[16]={0xeb,0xd0,0xa0,0xa2,0xb9,0xe5,0x44,0x33,0x87,0xc0,0x68,0xb6,0xb7,0x26,0x99,0xc7}
	uuid_t uu;
	DWORD senderCRC32_0=0;
	DWORD gpt_temp=0;
	DDWORD EX_sector=0;
	
	read_gpthead();//读取gpt头信息
	read_table();//读取gpt分区表信息到结构体
	
	printf("add size(MB):");
	scanf("%ld",&EX_sector);

	EX_sector=(EX_sector<<20)/512;
	printf("addsize: %lx\n%ldB= %ldKB= %ldMB= %ldGB\n",EX_sector,EX_sector*512,EX_sector*512>>10,EX_sector*512>>20,EX_sector*512>>30);

	for(int i=0; i<128; i++)//找到最后一个分区表的结束位置
	{
		if(gpt_temp<=ReverseBitsDD(GPT[i].EndingLBA))
			gpt_temp=ReverseBitsDD(GPT[i].EndingLBA);
	}
	uuid_generate_time(uu);//计算GUID
	
	for(int i=0;i<128;i++)
	{
		if(GPT[i].StartingLBA==0&&GPT[i].EndingLBA==0)
		{
			count=i;
			break;
		}
	}
	
	
	for(int i=0; i<16; i++)
	{
		GPT[count].PartitionTypeGUID[i]=_PartitionTypeGUID[i];
		GPT[count].UniquePartitionGUID[i]=uu[i];
	}
	//起点终点
	GPT[count].StartingLBA=ReverseBitsDD(gpt_temp+1);
	GPT[count].EndingLBA=ReverseBitsDD(gpt_temp+1+EX_sector);

	memset(GPT[count].Attributes,0,8);

	for(int i=0; i<72; i++)
	{
		GPT[count].PartitionName[i]=GPT[count-1].PartitionName[i];
	}
	
//写入备份分区
	fd = open("/dev/sda", O_RDWR);
     if (fd < 0)
     {
 		printf("open dev error\n");
 		return 0;
     }
	
	ret=readwriteblocktohd(DISK_WRITE,fd,head.AlternateLBA-32,32,(BYTE*)&GPT);
	if(ret)
	{
		printf("write  sector error\n");
		return -1;
	}
	ret=readwriteblocktohd(DISK_WRITE,fd,head.PartitionEntryLBA,32,(BYTE*)&GPT);
	if(ret)
	{
		printf("write  sector error\n");
		return -1;
	}

	//===========计算出CRC32后写入gpt头和备份区
	
	senderCRC32_0=0;
	InitializeCrc32Table();
	ret = CalculateCrc32((void *)&GPT,128*128,&senderCRC32_0);
     if(ret)
     {
          printf("cal the sender backup CRC32_0 error\n");
                    
          return 0;
     }
	printf("%x \n",senderCRC32_0);
	
//=====		
	
	ret=readwriteblocktohd(DISK_READ,fd,head.MyLBA,1,(BYTE*)&head);
	if(ret)
	{
		printf("read error\n");
		return -1;
	}
	head.PartitionEntryArrayCRC32=ReverseBitsD(senderCRC32_0);
	head.HeaderCRC32=0;
	printf("aaaa%x \n",head.PartitionEntryArrayCRC32);

	ret = CalculateCrc32((void *)&head,head.HeaderSize,&senderCRC32_0);
     if(ret)
     {
          printf("cal the sender backup CRC32_0 error\n");              
          return 0;
     }
	printf("%x \n",senderCRC32_0);
	
//=============
	head.HeaderCRC32=ReverseBitsD(senderCRC32_0);

//=========写入gpt备份区

	ret = readwriteblocktohd(DISK_WRITE,fd,head.AlternateLBA,1, (BYTE*)&head);
     if(ret)
     {
     	printf("read/write error%d\n",ret);
     }
//=========写入gpt头
	ret = readwriteblocktohd(DISK_WRITE,fd,head.MyLBA,1, (BYTE*)&head);
     if(ret)
     {
     	printf("read/write error%d\n",ret);
     }
	close(fd);
//============

	show_table();

}

int main()
{

    int fd = 0;
    WORD ret = 0;
    BYTE buff[512];
    int i = 0;
    BYTE buff_parttable[32*512];

    fd = open("/dev/sda", O_RDWR);
    if (fd < 0)
    {
	printf("open dev error\n");
	return 0;
    }
	add();
    ret = readwriteblocktohd(DISK_READ,fd,1,1, buff);
    if(ret)
    {
    	printf("read/write error%d\n",ret);
    }

    for(i = 0; i < 512; i++)
    {
    	printf("%02x ",buff[i]);
	if((i+1)%16 == 0)
	{
		printf("\n");
	}
	if((i+1)%128 == 0)
	{
		printf("\n");
	}
    }

/*
    int fd = 0;
    int tag = 1;
    WORD ret = 0;
	system("clear"); 
	//
	while(tag)
	{
		printf("// /dev/sda\n//=========================\n");
		printf("            1.check\n            2.add\n            3.del\n            4.quit\n");
		printf("type in the number:");
		scanf("%d", &tag);
		switch(tag)
		{
			case 1:
			{
				check();
				show_table();
				break;
			}
			case 2:
			{
				add();
				break;
			}
			case 3:
			{
				
				del();
				break;
			}
			case 4:
			{
				return 0;
				break;
			}
			default:
			{
				printf("input error\n");
				return 0;
			}
		}
	}
*/
    return 0;
}










沧月灬张煜
关注
专栏目录
win10 linux efi分区大小,EFI模式 win10+Ubuntu16.04双系统
weixin_30120123的博客
05-08 4684
EFI模式 win10+Ubuntu16.04双系统Linux Ubuntu在Windows下只需要分出一块较大的未分配空间就行，记住不要去格式化，保证其“未分配”属性(Linux的文件系统和Win是不一样的，NTFS和FAT32都不适用)。你必须要有一个U盘，既然我们UEFI启动，那就不需要刻录这么麻烦的工作了，直接将iso里的所有文件解压至U盘即可。Ubuntu的镜像文件里本身就有EFI文件夹...
windows和linux共用efi分区,技术|使用 UEFI 双启动 Windows 和 Linux
weixin_33504929的博客
05-03 2618
这是一份在同一台机器上设置 Linux 和 Windows 双重启动的速成解释，使用统一可扩展固件接口(UEFI)。我将强调一些重要点，而不是一步一步地指导你来如何配置你的系统以实现双重启动。作为一个示例，我将提到我在几个月之前新买的笔记本计算机。我先是安装Ubuntu Linux到整个硬盘中，这就摧毁了预装的Windows 10环境。几个月后，我决定安装一个不同的 Linux 发行版F...
GPT分区
TK_Lumi的博客
12-21 516
GPT分区一、介绍二、案例 一、介绍 分区模式GPT GPT，GUID Partition Table –全局唯一标识分区表 –突破固定大小64字节的分区表限制 –最多可支持128个主分区，最大支持18EB容量 1 EB = 1024 PB = 1024 x 1024 TB 二、案例 parted常用分区指令 –help //查看指令帮助 –mktable gpt //建立指定模式分区表 –mkpart 分区的名称 文件系统类型 start end //指定大小或
Linux下超大硬盘分构(GPT分区)
鹿鸣天涯
06-25 2428
安装CentOS5.3 时，遇到的问题： 硬件环境：Dell R710，6块SATA 1T容量、7.2k转的磁盘，6i RAID卡。 问题：将前5块盘做的RAID5，共4T左右的存储容量。将第六块盘做的全局热备。 安装CentOS5.3时提示： Your boot partition is on a disk using the GPT partitioning Scheme but t...
linux下访问windows分区,Linux下访问Windows硬盘分区
weixin_36255718的博客
05-05 537
在Red Hat Linux下访问Windows系统的硬盘分区很简单。因为Red Hat Linux提供了对几乎所有文件系统的支持，因此它可以直接读写Windows系统的分区。安装Red Hat Linux 时，就可以指出计算机中存在的Windows分区的位置，并指定想要将它们载入到Linux文件系统中的位置。通常，将Windows系统中C盘的内容载入到Linux系统下的目录/mnt/c，这时就可...
gpt linux双系统安装win7系统分区格式化,UEFI引导GPT安装64位Win7|Win7如何使用磁盘格式为GPT分区重装系统...
weixin_29485887的博客
05-03 837
UEFI+GPT引导模式，也就是各大PC厂商在给电脑出厂时自带win10系统的默认磁盘格式，使用普通工具是无法正常重装win7的，除非支持GPT分区的一键修复，一键重装工具。这篇文章是老牌一键重装系统给那些想用UEFI+GPT重装win7系统用户的教程文章，希望能帮助到大家。GPT(GUID Partition Table)中文名称叫做全局唯一标识分区表。它和MBR分区的区别就是引导方式和分区结构...
UEFI启动+GPT分区模式下双硬盘SSD+HDD+Win10安装Ubuntu18.04.1组成双系统
Famir Tse的博客
10-18 4857
以下叙述均基于UEFI+GPT模式 环境： 处理器、内存、系统： 硬盘：256G三星固态盘+2T希捷SATA机械盘 Win10已经安装在固态 安装流程 准备空闲分区 磁盘管理中选择压缩卷，固态还能分出150G左右给Ubuntu，另在机械盘分出了200G左右。硬盘分区如下（此为已完成安装图）： 注：机械盘压缩时提示空间不足，实际上空间足够，查询猜测是碎片太多所致，用win10自带的碎片整理，优化...
单EFI分区Archlinux + Windows 10 双启动安装记录
最新发布
kimux的博客
01-16 1320
单EFI分区Archlinux + Windows 10 双启动安装记录
windows10+Manjaro安装双系统（单硬盘）折腾笔记
06-27
当前主流的两种启动系统方式是 Legacy启动+MBR 分区表和 UEFI 启动+GPT 分区表。我们可以通过文件资源管理器->（右键）此电脑->管理->磁盘管理，选择一个磁盘，右键查看磁盘属性中的卷一栏来查看电脑支持的启动方式...
双硬盘SSD+HDD，安装win10+Ubuntu18.04双系统（安装超详解）（UEFI启动+GPT分区）(或许是你正在解决的问题？)
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
10-23 7682
本文在WIN10下Ubuntu 18.04，磁盘格式是GTP，同时使用UEFI引导。Win10安装在固态盘，Ubuntu引导启动项在固态盘，系统在机械盘。 （注意，网上有些教程已经过时，不自在适应新机器；或许你遇到的问题，本文都有解；） 双硬盘SSD+HDD，安装win10+Ubuntu18.04双系统（UEFI启动+GPT分区）一、前期了解（直接影响安装双系统的方法）1.查看BIOS模式2.查看硬盘格式二、准备工作1.下载 Ubuntu 镜像2.制作启动U盘3.给 Ubuntu 分配硬盘空间三、安装ubu
Linux使用fdisk进行gpt超大磁盘的分区与挂载
周大侠的博客
08-04 4396
创建分区 [root@7-64-test ~]# fdisk -l //查询磁盘情况 Disk /dev/sda: 21.5 GB, 21474836480 bytes, 41943040 sectors Units = sectors of 1 * 512 = 512 bytes Sector size (logical/physical): 512 bytes / 512 bytes I/O size (minimum/optimal): 512 bytes / 512 bytes ...
关于windows装ubuntu双系统的问题
qq_29703971的博客
11-01 3907
自用：双系统ubuntu安装配置
UEFI 双系统+双硬盘安装
chumingqian的博客
06-20 7905
确认自己的BIOS 启动是 Legacy 还是UEFI， 一般2020年之后的机型都是UEFI 的启动类型了。硬盘接入主板的时候， 有两根线， 分别是 用作硬盘的数据线（短口）以及硬盘的电源线（宽口）首先在win10 打开， 管理——> ， 将新接入的硬盘进行初始化， 此时该电脑便会识别出一个新的硬盘；如图所示， 我们我们选中 ,然后点击右边的 新建一个分区表， 注意这个步骤， 只会将我们的 设备进行重新格式化， 也就是这个步骤会将我们的新硬盘重新格式化， （如果电脑上只有一个硬盘上， 该步骤会
Linux系统配置需要bootefi分区
十色花的博客
07-01 2万+
安装centos6在分区时发现缺少/boot/efi分区，需要在开机F10之后进入lifecycle controller之后，选择BIOS或者UEFI时，选择后者即可，后续配置分区时，即可发现/boot/efi分区。...
Win10+Ubuntu18.04 亲测UEFI启动模式双硬盘+双系统成功安装经验
热门推荐
xrinosvip的博客
06-20 8万+
温馨提示： 本贴适用于 Win10 UEFI 模式启动+双硬盘（固态硬盘+机械硬盘）安装 ubuntu18.04 双系统 本人电脑型号： 戴尔游匣5575 （128固态+1T机械硬盘），Win10UEFI启动模式，64位操作系统 ubuntu18.04下载链接：https://www.ubuntu.com/download/desktop 系统安装过程应注意的事项： 1、安装原理...
win+linux双系统卸载及EFI系统分区删除
qq_39740292的博客
03-20 6006
UEFI分区删除，双系统删除
Dell电脑 两块硬盘的efi启动分配
Ripo_za的博客
12-01 6274
如果有电脑有两块硬盘的小伙伴可以参考这个设置的硬盘（其实也没必要，只要有一个系统能进就行，然后在把把别的系统引导加进来就行，但是强迫症让我必须知道咋着能改，要不心里难受。。。。。）。 我的是dell的电脑+efi启动，其他的可能不适用，做个参考把。 在boot下面选择有Add boot的那个选项，然后可以看见有两个硬盘了。 找到每个硬盘的esp分区（带有EFI文件夹的分区），可以看见该硬...
双硬盘双系统解决引导在同一个分区的问题
u013511885的博客
09-27 1万+
双硬盘[SSD+HDD]+双系统[win10+Ubuntu16.04]问题描述问题解决合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出...
新加装的硬盘，装上系统后发现EFI分区没有被创建，还是用旧硬盘的EFI分区
u013580080的博客
06-24 3万+
目前情况大概就是这个样子：（本人忘了截图，用别人的） 可见，装好系统在HD0后，只有一个MSR分区，没有ESP（EFI）分区，原因是重装时候还插着HDD，所以安装程序检测到HD1已经有中的ESP，就没有在SSD上再新建ESP。 不重装系统不需要U盘的解决办法： 1、利用系统的磁盘管理在新硬盘中腾出一块100M到300M的空闲空间 2、用管理员命令提示符，打开diskpart模式（直
Windows系统识别GPT大磁盘补丁：gpt_disk_patch下载
"windows操作识别gpt大磁盘系统补丁gpt_disk_patch"就是针对这种情况设计的。这个补丁允许这些旧版Windows系统能够识别和管理使用GPT分区的大磁盘。在安装补丁之前，用户需要确保他们的系统满足补丁的兼容性要求，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值