精华内容
下载资源
问答
  • 面对一块新的磁盘,我们首先要做的就是对其初始化。在系统中通过windows的磁盘管理完成这一点非常容易,但在程序中实现略微复杂。本节的示例代码对一块新硬盘初始化,并在上面创建分区。 代码如下:   /******
    

    上一节中我们介绍了一些基本概念和主要的API,本节开始我们将列举并分析一些实例。本文中的所有代码我都在vs2008下测试过,读者只需要替换少量的宏定义即可编译执行。

     
    面对一块新的磁盘,我们首先要做的就是对其初始化。在系统中通过windows 的磁盘管理完成这一点非常容易,但在程序中实现略微复杂。本节的示例代码对一块新硬盘初始化,并在上面创建分区。
    代码如下:
     
    /******************************************************************************
    * Function: initialize the disk and create partitions
    * input: disk, disk name
    *         parNum, partition number
    * output: N/A
    * return: Succeed, 0
    *          Fail, -1
    ******************************************************************************/
    DWORD CreateDisk(DWORD disk, WORD partNum)
    {
        HANDLE hDevice;               // handle to the drive to be examined
        BOOL result;                  // results flag
        DWORD readed;                 // discard results
        DWORD ret;
        WORD i;
        CHAR diskPath[DISK_PATH_LEN];
        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(diskPath, "\\\\.\\PhysicalDrive%d", disk);
     
        actualPartNum = 4;
        if (partNum > actualPartNum)
        {
            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
        newDisk.PartitionStyle = PARTITION_STYLE_MBR;
        signature = (DWORD)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
        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(diskPath, &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 / partNum;
     
        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
        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 < partNum; 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
        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);
        Sleep(3000);            //wait the operations take effect
        return 0;
    }
     
    函数 CreateDisk 包含两个参数,
    DWORD disk 填入物理驱动器号,参见第一节。
    WORD partNum 表示需要创建的分区数, partNum <= 4
     
    函数的执行流程解释如下:
    /*************** 初始化磁盘*****************/
    1.  根据disk 创建设备名称,\\\\.\\PhysicalDriveX ,这里由于要转义,所以”\” 都写为”\\”
    2.  调用CreateFile 打开设备文件,并获得句柄。
    3.  用操作码 IOCTL_DISK_CREATE_DISK 调用 DeviceIoControl 函数,初始化磁盘并创建分区表。
    使用 IOCTL_DISK_CREATE_DISK 操作码时,lpInBuffer 要填入一个 CREATE_DISK 结构参数,其中包括分区表类型和磁盘签名等参数,详见MSDN 。本例中创建MBR 分区表,签名由当前时间产生。
    4.  刷新分区表。注意,程序中任何时候对磁盘的分区信息进行了修改都需要调用操作码为 IOCTL_DISK_UPDATE_PROPERTIES DeviceIoControl 函数来刷新分区表,是操作切实生效。
    /**************** 创建分区*******************/
    5.  调用 GetDriveGeometry 获取磁盘信息(GetDriveGeometry 参见上一节http://cutebunny.blog.51cto.com/301216/624027)。由于创建分区时要填入分区大小信息,我们此处先计算磁盘总大小,然后除以partNum 将字节数平均分配到各个分区。
    6.  分配 DRIVE_LAYOUT_INFORMATION_EX 结构体空间。我们通过在这个结构体中填入数据来指定如何对硬盘进行分区。结构体定义如下
    typedef struct _DRIVE_LAYOUT_INFORMATION_EX {
    DWORD PartitionStyle;
    DWORD PartitionCount;
    union {
        DRIVE_LAYOUT_INFORMATION_MBR Mbr;
        DRIVE_LAYOUT_INFORMATION_GPT Gpt;
    };
    PARTITION_INFORMATION_EX PartitionEntry[1];
    } DRIVE_LAYOUT_INFORMATION_EX,
     *PDRIVE_LAYOUT_INFORMATION_EX;
           其中 PartitionCount 4 的倍数,为简化处理,我们这里定死为4
           另外还要注意 PARTITION_INFORMATION_EX 型的数组 PartitionEntry[1] 。虽然结构体中只定义了一个元素,但事实上必须在其后补足PartitionCount – 1 个元素。所以代码中为DRIVE_LAYOUT_INFORMATION_EX *dl 分配空间的时候加上了(actualPartNum - 1) * sizeof(PARTITION_INFORMATION_EX)
    7.  DRIVE_LAYOUT_INFORMATION_EX 结构体空间dl 中填入数据。
    先将所有分区都设为 PARTITION_ENTRY_UNUSED ,后面具体分配多少个分区再设置回来。
    然后再循环体内对每个分区的PartitionEntry 赋值,其中
    StartingOffset 除了跳过前面的分区已占据的空间外,还要加上63 个扇区空间(32256 字节)。
    PartitionNumber 1 开始。
    Mbr.PartitionType = PARTITION_IFS 表示NTFS 格式。
    Mbr.HiddenSectors MSDN 上说The number of hidden sectors to be allocated when the partition table is created. 我理解得不是很深刻,欢迎补充。
    8.  调用操作码为 IOCTL_DISK_SET_DRIVE_LAYOUT_EX DeviceIoControl 函数执行分区,参数需要填入刚才准备好的 DRIVE_LAYOUT_INFORMATION_EX 结构体和大小。
    9.  刷新分区表,原理同4
    另外,我在函数末尾加上了Sleep(3000) 。这是因为我发现创建分区操作需要一定的执行时间,如果后续紧跟着其它相关操作(例如格式化该分区)可能会产生分区不存在的错误,所以此处等待3 秒确保其执行完毕。
    本节涉及的类型较多,但各类型具有很强的关联性,读者可随时查阅MSDN获得更详细的说明。

     

    本文出自 “bunny技术坊” 博客,请务必保留此出处http://cutebunny.blog.51cto.com/301216/624052

    展开全文
  • windows下初始化格式化磁盘

    千次阅读 2018-07-31 19:53:53
    新买来的硬盘是未初始化的,以我的理解就是没有引导扇区的,通常是没有...左边显示“没有初始化”, 点鼠标右键就可以【初始化磁盘】。 初始化时可以选择MBR和GPT, MBR方式顶多支持2T硬盘的。 初始化后 ...

    转载自:https://blog.csdn.net/wuzuyu365/article/details/52881692

    新买来的硬盘是未初始化的,以我的理解就是没有引导扇区的,通常是没有MBR,如下图磁盘1,右边有大小,但显示“未分配”,

    左边显示“没有初始化”, 点鼠标右键就可以【初始化磁盘】。

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

    初始化后

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

     

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

     

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

     

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

     

    代码: 

    CPP:CMDiskManager.cpp

     

     
    1. #include "stdafx.h"

    2. #include "CMDiskManager.h"

    3.  
    4. CMDiskManager::CMDiskManager(){}

    5.  
    6. //获取磁盘大小,单位是MB

    7. int CMDiskManager::GetDiskSize(DWORD vDiskNo)

    8. {

    9. HANDLE hDevice; // handle to the drive to be examined

    10. BOOL bResult; // results flag

    11. DWORD junk; // discard results

    12.  
    13. char diskPath[256]; //磁盘内部路径

    14. //生成磁盘内部路径

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

    16.  
    17. hDevice = CreateFile(TEXT(diskPath), // drive 或者 用"\\\\.\\PhysicalDrive0" 代表第一块磁盘

    18. GENERIC_READ, // no access to the drive

    19. FILE_SHARE_READ | // share mode

    20. FILE_SHARE_WRITE,

    21. NULL, // default security attributes

    22. OPEN_EXISTING, // disposition

    23. 0, // file attributes

    24. NULL); // do not copy file attributes

    25.  
    26. if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive

    27. {

    28. return (FALSE);

    29. }

    30.  
    31. GET_LENGTH_INFORMATION pdg;

    32. bResult = DeviceIoControl(hDevice, // device to be queried

    33. IOCTL_DISK_GET_LENGTH_INFO, // operation to perform

    34. NULL, 0, // no input buffer

    35. &pdg, sizeof(pdg), // output buffer

    36. &junk, // # bytes returned

    37. (LPOVERLAPPED)NULL); // synchronous I/O

    38.  
    39. CloseHandle(hDevice);

    40.  
    41. /* INT64 nUseSize = disk_len.Length.QuadPart;

    42. INT64 sizeGB = nUseSize / 1014 / 1024 / 1024;

    43. CString szSize;

    44. szSize.Format(L"C盘大小 %I64d GB", sizeGB);

    45. */

    46. int MB = pdg.Length.QuadPart >> 20;

    47. //CString s;

    48. //s.Format("C盘大小 %f GB", MB/1024.0);

    49. //AfxMessageBox(s, 0, MB_OK);

    50. //float x = (float) MB ;

    51. return MB ;

    52. }

    53.  
    54.  
    55. /*

    56. 获取磁盘分区个数

    57. vDiskNo:磁盘序号

    58. */

    59. int CMDiskManager::GetPartNum(DWORD vDiskNo)

    60. {

    61. char diskPath[256]; //磁盘内部路径

    62. //生成磁盘内部路径

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

    64. HANDLE hDevice; //硬盘句柄 handle to the drive to be examined

    65. BOOL result; //结果标志 results flag

    66. DWORD readed; // discard results

    67.  
    68. hDevice = CreateFile(

    69. diskPath,

    70. GENERIC_READ | GENERIC_WRITE,

    71. FILE_SHARE_READ | FILE_SHARE_WRITE,

    72. NULL, //default security attributes

    73. OPEN_EXISTING, // disposition

    74. 0, // file attributes

    75. NULL

    76. );

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

    78. {

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

    80. return int(-1);

    81. }

    82.  
    83. DRIVE_LAYOUT_INFORMATION_EX* dl;

    84. DWORD tSize = 0x4000; // sizeof(DRIVE_LAYOUT_INFORMATION_EX) * 10;

    85. dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(tSize);

    86. if (NULL == dl)

    87. {

    88. (void)CloseHandle(hDevice);

    89. return (int)-2;

    90. }

    91.  
    92. result = DeviceIoControl(

    93. hDevice,

    94. IOCTL_DISK_GET_DRIVE_LAYOUT_EX,

    95. NULL,

    96. 0,

    97. dl,

    98. tSize,

    99. &readed,

    100. NULL

    101. );

    102.  
    103. if (!result)

    104. {

    105. fprintf(stderr, "IOCTL_DISK_GET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());

    106. (void)CloseHandle(hDevice);

    107. return int(-3);

    108. }

    109.  
    110. CString tPartitionStyle = "RAW";

    111. switch (dl->PartitionStyle){

    112. case 0:

    113. tPartitionStyle = "MBR";

    114. break;

    115. case 1:

    116. tPartitionStyle = "GPT";

    117. break;

    118. }

    119.  
    120. //printf("dl->PartitionCount = %d", dl->PartitionCount);

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

    122.  
    123. //printf("dl->PartitionCount = %d", dl->PartitionCount);

    124. int tRet = dl->PartitionCount/4;

    125. //TRACE("dl->PartitionCount tRet = %d", tRet);

    126.  
    127. free(dl);

    128. (void)CloseHandle(hDevice);

    129.  
    130. return tRet;

    131. }

    132.  
    133. //读MBR信息

    134. BOOL CMDiskManager::ReadMBR(int vDiskNo, LPVOID *pBuffer)

    135. {

    136. HANDLE hDevice;

    137. DWORD dwSize;

    138. DWORD dwOverRead;

    139. BOOL bRet = TRUE;

    140. char diskPath[256]; //磁盘内部路径

    141. //生成磁盘内部路径

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

    143.  
    144. hDevice = CreateFile(TEXT(diskPath),

    145. GENERIC_READ | GENERIC_WRITE,

    146. FILE_SHARE_READ | FILE_SHARE_WRITE,

    147. NULL,

    148. OPEN_EXISTING,

    149. 0,

    150. NULL);

    151. if (hDevice == INVALID_HANDLE_VALUE) {

    152. TRACE("Open \\\\.\\PhysicalDrive failed. Error=%u\n", GetLastError());

    153. return FALSE;

    154. }

    155.  
    156. if (!DeviceIoControl(hDevice, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL)) {

    157. CloseHandle(hDevice);

    158. TRACE("FSCTL_LOCK_VOLUME \\\\.\\PhysicalDrive0 failed. Error=%u\n", GetLastError());

    159. return FALSE;

    160. }

    161.  
    162. DISK_GEOMETRY Geometry;

    163. if (!DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &Geometry, sizeof(DISK_GEOMETRY), &dwSize, NULL)) {

    164. bRet = FALSE;

    165. TRACE("IOCTL_DISK_GET_DRIVE_GEOMETRY \\\\.\\PhysicalDrive0 failed. Error=%u\n", GetLastError());

    166. goto _out;

    167. }

    168.  
    169. *pBuffer = (LPVOID)GlobalAlloc(GPTR, Geometry.BytesPerSector);

    170. if (*pBuffer) {

    171. if (!ReadFile(hDevice, *pBuffer, Geometry.BytesPerSector, &dwOverRead, NULL)) {

    172. printf("ReadFile \\\\.\\PhysicalDrive %u bytes failed. Error=%u\n", Geometry.BytesPerSector, GetLastError());

    173. bRet = FALSE;

    174. }

    175. }

    176.  
    177. _out:

    178. DeviceIoControl(hDevice, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &dwSize, NULL);

    179. CloseHandle(hDevice);

    180. return bRet;

    181.  
    182. }

    183.  
    184.  
    185. /*

    186. 获取磁盘分区信息

    187. vDiskNo:磁盘序号

    188. */

    189. DWORD CMDiskManager::GetLayoutInfo(DWORD vDiskNo)

    190. {

    191. char diskPath[256]; //磁盘内部路径

    192. //生成磁盘内部路径

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

    194. HANDLE hDevice; //硬盘句柄 handle to the drive to be examined

    195. BOOL result; //结果标志 results flag

    196. DWORD readed; // discard results

    197.  
    198. hDevice = CreateFile(

    199. diskPath,

    200. GENERIC_READ | GENERIC_WRITE,

    201. FILE_SHARE_READ | FILE_SHARE_WRITE,

    202. NULL, //default security attributes

    203. OPEN_EXISTING, // disposition

    204. 0, // file attributes

    205. NULL

    206. );

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

    208. {

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

    210. return DWORD(-1);

    211. }

    212.  
    213. DRIVE_LAYOUT_INFORMATION_EX* dl;

    214. DWORD tSize = 0x4000; // sizeof(DRIVE_LAYOUT_INFORMATION_EX) * 10;

    215. dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(tSize);

    216. if (NULL == dl)

    217. {

    218. (void)CloseHandle(hDevice);

    219. return (WORD)-1;

    220. }

    221.  
    222. result = DeviceIoControl(

    223. hDevice,

    224. IOCTL_DISK_GET_DRIVE_LAYOUT_EX,

    225. NULL,

    226. 0,

    227. dl,

    228. tSize,

    229. &readed,

    230. NULL

    231. );

    232.  
    233. if (!result)

    234. {

    235. fprintf(stderr, "IOCTL_DISK_GET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());

    236. (void)CloseHandle(hDevice);

    237. return DWORD(-1);

    238. }

    239.  
    240. CString tPartitionStyle = "RAW";

    241. switch (dl->PartitionStyle){

    242. case 0:

    243. tPartitionStyle = "MBR";

    244. break;

    245. case 1:

    246. tPartitionStyle = "GPT";

    247. break;

    248. }

    249.  
    250. //printf("dl->PartitionCount = %d", dl->PartitionCount);

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

    252.  
    253. free(dl);

    254. (void)CloseHandle(hDevice);

    255.  
    256. return 0;

    257. }

    258.  
    259. /*

    260. 初始化磁盘,创建分区

    261. vDiskNo:磁盘序号,千万要避开系统盘,系统盘一般是0

    262. vPartNum:分区数,只要1个分区就可以了

    263. */

    264. DWORD CMDiskManager::CreateDisk(DWORD vDiskNo, WORD vPartNum)

    265. {

    266. printf("准备CreateDisk, vDiskNo=%d, vPartNum=%d \n", vDiskNo, vPartNum);

    267.  
    268. //第0块磁盘是系统盘,不能格式化掉!!!但不排除某些情况下新插入的移动硬盘会是第0块磁盘

    269. if (0 == vDiskNo){

    270. printf("第0块磁盘是系统盘,不能格式化掉\n");

    271. return 0;

    272. }

    273.  
    274. HANDLE hDevice; //硬盘句柄 handle to the drive to be examined

    275. BOOL result; //结果标志 results flag

    276. DWORD readed; // discard results

    277. DWORD ret;

    278. WORD i;

    279. char diskPath[256]; //磁盘内部路径

    280. DISK_GEOMETRY pdg;

    281. DWORD sectorSize; //扇区大小

    282. DWORD signature; //签名

    283. LARGE_INTEGER diskSize; //磁盘大小

    284. LARGE_INTEGER partSize; //分区大小

    285. BYTE actualPartNum; //实际上的分区数

    286.  
    287. DWORD layoutStructSize; //

    288. DRIVE_LAYOUT_INFORMATION_EX *dl; //磁盘分区信息

    289. CREATE_DISK newDisk; //创建磁盘(初始化?)

    290.  
    291. //生成磁盘内部路径

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

    293.  
    294. actualPartNum = 4;

    295. if (vPartNum > actualPartNum)

    296. {

    297. printf("vPartNum > 4\n");

    298. return (WORD)-1;

    299. }

    300.  
    301. hDevice = CreateFile(

    302. diskPath,

    303. GENERIC_READ | GENERIC_WRITE,

    304. FILE_SHARE_READ | FILE_SHARE_WRITE,

    305. NULL, //default security attributes

    306. OPEN_EXISTING, // disposition

    307. 0, // file attributes

    308. NULL

    309. );

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

    311. {

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

    313. return DWORD(-1);

    314. }

    315.  
    316. // Create primary partition MBR

    317. //创建主分区的MBR

    318. printf("创建主分区的MBR\n");

    319.  
    320. newDisk.PartitionStyle = PARTITION_STYLE_MBR;

    321. signature = (DWORD)time(0); // 原为time(NULL), get signature from current time

    322. newDisk.Mbr.Signature = signature;

    323.  
    324. result = DeviceIoControl(

    325. hDevice,

    326. IOCTL_DISK_CREATE_DISK,

    327. &newDisk,

    328. sizeof(CREATE_DISK),

    329. NULL,

    330. 0,

    331. &readed,

    332. NULL

    333. );

    334. if (!result)

    335. {

    336. fprintf(stderr, "IOCTL_DISK_CREATE_DISK Error: %ld\n", GetLastError());

    337. (void)CloseHandle(hDevice);

    338. return DWORD(-1);

    339. }

    340.  
    341. //fresh the partition table

    342. //刷新分区表

    343. printf("刷新分区表\n");

    344. result = DeviceIoControl(

    345. hDevice,

    346. IOCTL_DISK_UPDATE_PROPERTIES,

    347. NULL,

    348. 0,

    349. NULL,

    350. 0,

    351. &readed,

    352. NULL

    353. );

    354. if (!result)

    355. {

    356. fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());

    357. (void)CloseHandle(hDevice);

    358. return DWORD(-1);

    359. }

    360.  
    361. //Now create the partitions

    362. //现在创建分区

    363. ret = GetDriveGeometry(vDiskNo, &pdg);

    364. if ((DWORD)-1 == ret)

    365. {

    366. return ret;

    367. }

    368.  
    369. //扇区大小

    370. sectorSize = pdg.BytesPerSector;

    371. diskSize.QuadPart = pdg.Cylinders.QuadPart * pdg.TracksPerCylinder *

    372. pdg.SectorsPerTrack * pdg.BytesPerSector; //calculate the disk size;

    373. partSize.QuadPart = diskSize.QuadPart / vPartNum;

    374.  
    375. //分区结构大小

    376. layoutStructSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + (actualPartNum - 1) * sizeof(PARTITION_INFORMATION_EX);

    377. dl = (DRIVE_LAYOUT_INFORMATION_EX*)malloc(layoutStructSize);

    378. if (NULL == dl)

    379. {

    380. (void)CloseHandle(hDevice);

    381. return (WORD)-1;

    382. }

    383.  
    384. dl->PartitionStyle = (DWORD)PARTITION_STYLE_MBR;

    385. dl->PartitionCount = actualPartNum;

    386. dl->Mbr.Signature = signature;

    387.  
    388. //clear the unused partitions

    389. //清除未用的分区

    390. printf("清除未用的分区\n");

    391. for (i = 0; i < actualPartNum; i++){

    392. dl->PartitionEntry[i].RewritePartition = 1;

    393. dl->PartitionEntry[i].Mbr.PartitionType = PARTITION_ENTRY_UNUSED;

    394. }

    395.  
    396. //set the profile of the partitions

    397. for (i = 0; i < vPartNum; i++){

    398. dl->PartitionEntry[i].PartitionStyle = PARTITION_STYLE_MBR;

    399. dl->PartitionEntry[i].StartingOffset.QuadPart =

    400. (partSize.QuadPart * i) + ((LONGLONG)(pdg.SectorsPerTrack) * (LONGLONG)(pdg.BytesPerSector)); //32256

    401. dl->PartitionEntry[i].PartitionLength.QuadPart = partSize.QuadPart;

    402. dl->PartitionEntry[i].PartitionNumber = i + 1;

    403. dl->PartitionEntry[i].RewritePartition = TRUE;

    404. dl->PartitionEntry[i].Mbr.PartitionType = PARTITION_IFS;

    405. dl->PartitionEntry[i].Mbr.BootIndicator = FALSE;

    406. dl->PartitionEntry[i].Mbr.RecognizedPartition = TRUE;

    407. dl->PartitionEntry[i].Mbr.HiddenSectors =

    408. pdg.SectorsPerTrack + (DWORD)((partSize.QuadPart / sectorSize) * i);

    409. }

    410. //execute the layout

    411. result = DeviceIoControl(

    412. hDevice,

    413. IOCTL_DISK_SET_DRIVE_LAYOUT_EX,

    414. dl,

    415. layoutStructSize,

    416. NULL,

    417. 0,

    418. &readed,

    419. NULL

    420. );

    421. if (!result)

    422. {

    423. fprintf(stderr, "IOCTL_DISK_SET_DRIVE_LAYOUT_EX Error: %ld\n", GetLastError());

    424. free(dl);

    425. (void)CloseHandle(hDevice);

    426. return DWORD(-1);

    427. }

    428.  
    429. //fresh the partition table

    430. printf("刷新分区表\n");

    431. result = DeviceIoControl(

    432. hDevice,

    433. IOCTL_DISK_UPDATE_PROPERTIES,

    434. NULL,

    435. 0,

    436. NULL,

    437. 0,

    438. &readed,

    439. NULL

    440. );

    441. if (!result)

    442. {

    443. fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());

    444. free(dl);

    445. (void)CloseHandle(hDevice);

    446. return DWORD(-1);

    447. }

    448.  
    449. free(dl);

    450. (void)CloseHandle(hDevice);

    451. printf("CreateDisk完成\n");

    452. Sleep(3000); //wait the operations take effect

    453. return 0;

    454. }

    455.  
    456.  
    457. //获取磁盘几何信息

    458. BOOL CMDiskManager::GetDriveGeometry(DWORD vDiskNo, DISK_GEOMETRY *pdg)

    459. {

    460. HANDLE hDevice; // handle to the drive to be examined

    461. BOOL bResult; // results flag

    462. DWORD junk; // discard results

    463.  
    464. char diskPath[256]; //磁盘内部路径

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

    466.  
    467. hDevice = CreateFile(TEXT(diskPath), // drive

    468. 0, // no access to the drive

    469. FILE_SHARE_READ | // share mode

    470. FILE_SHARE_WRITE,

    471. NULL, // default security attributes

    472. OPEN_EXISTING, // disposition

    473. 0, // file attributes

    474. NULL); // do not copy file attributes

    475.  
    476. if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive

    477. {

    478. return (FALSE);

    479. }

    480.  
    481. bResult = DeviceIoControl(hDevice, // device to be queried

    482. IOCTL_DISK_GET_DRIVE_GEOMETRY, // operation to perform

    483. NULL, 0, // no input buffer

    484. pdg, sizeof(*pdg), // output buffer

    485. &junk, // # bytes returned

    486. (LPOVERLAPPED)NULL); // synchronous I/O

    487.  
    488. CloseHandle(hDevice);

    489.  
    490. return (bResult);

    491. }

    492.  
    493.  
    494. /******************************************************************************

    495. * Function: delete the partition layout of the disk

    496. 删除磁盘分区信息(恢复出厂设置)

    497. * input: disk, disk name

    498. * output: N/A

    499. * return: Succeed, 0

    500. * Fail, -1

    501. ******************************************************************************/

    502. DWORD CMDiskManager::DestroyDisk(DWORD vDiskNo)

    503. {

    504. if (0 == vDiskNo){

    505. //系统盘是0号盘,为了安全,不能删除

    506. return 0;

    507. }

    508.  
    509. HANDLE hDevice; // handle to the drive to be examined

    510. BOOL result; // results flag

    511. DWORD readed; // discard results

    512. CHAR diskPath[256];

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

    515.  
    516. hDevice = CreateFile(

    517. diskPath, // drive to open

    518. GENERIC_READ | GENERIC_WRITE, // access to the drive

    519. FILE_SHARE_READ | FILE_SHARE_WRITE, //share mode

    520. NULL, // default security attributes

    521. OPEN_EXISTING, // disposition

    522. 0, // file attributes

    523. NULL // do not copy file attribute

    524. );

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

    526. {

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

    528. return DWORD(-1);

    529. }

    530.  
    531. result = DeviceIoControl(

    532. hDevice, // handle to device

    533. IOCTL_DISK_DELETE_DRIVE_LAYOUT, // dwIoControlCode

    534. NULL, // lpInBuffer

    535. 0, // nInBufferSize

    536. NULL, // lpOutBuffer

    537. 0, // nOutBufferSize

    538. &readed, // number of bytes returned

    539. NULL // OVERLAPPED structure

    540. );

    541. if (!result)

    542. {

    543. //fprintf(stderr, "IOCTL_DISK_DELETE_DRIVE_LAYOUT Error: %ld\n", GetLastError());

    544. (void)CloseHandle(hDevice);

    545. return DWORD(-1);

    546. }

    547.  
    548. //fresh the partition table

    549. result = DeviceIoControl(

    550. hDevice,

    551. IOCTL_DISK_UPDATE_PROPERTIES,

    552. NULL,

    553. 0,

    554. NULL,

    555. 0,

    556. &readed,

    557. NULL

    558. );

    559. if (!result)

    560. {

    561. fprintf(stderr, "IOCTL_DISK_UPDATE_PROPERTIES Error: %ld\n", GetLastError());

    562. (void)CloseHandle(hDevice);

    563. return DWORD(-1);

    564. }

    565.  
    566. (void)CloseHandle(hDevice);

    567. return 0;

    568. }

    569.  
    570. /******************************************************************************

    571. * Function:快速格式化某个磁盘,文件系统NTFS,

    572. 如果在CreateDisk()创建磁盘后,磁盘的文件系统是RAW的话,才需要调用该函数

    573. * input: disk, disk name

    574. * output: N/A

    575. * return: Succeed, 0

    576. * Fail, 1

    577. ******************************************************************************/

    578. DWORD CMDiskManager::FormatVolume(CHAR letter)

    579. {

    580. DWORD ret;

    581. CHAR cmd[64];

    582. sprintf(cmd, "format %c: /FS:NTFS /Q /Y", letter);

    583. ret = (DWORD)system(cmd);

    584. return ret;

    585. }

    586.  
    587. //获取第dwNum个磁盘的信息

    588. void CMDiskManager::GetDiskInfo(DWORD &dwNum, CString chDriveInfo[])

    589. {

    590. DWORD DiskCount = 0;

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

    593. DWORD DiskInfo = GetLogicalDrives();

    594.  
    595. //通过循环操作查看每一位数据是否为1,如果为1则磁盘为真,如果为0则磁盘不存在。

    596. while (DiskInfo)

    597. {

    598. //通过位运算的逻辑与操作,判断是否为1

    599. Sleep(10);

    600. if (DiskInfo & 1)

    601. {

    602. DiskCount++;

    603. }

    604. DiskInfo = DiskInfo >> 1;//通过位运算的右移操作保证每循环一次所检查的位置向右移动一位。*/

    605. }

    606.  
    607. if (dwNum < DiskCount)

    608. {

    609. return;//实际的磁盘数目大于dwNum

    610. }

    611. dwNum = DiskCount;//将磁盘分区数量保存

    612.  
    613.  
    614. //-------------------------------------------------------------------//

    615. //通过GetLogicalDriveStrings()函数获取所有驱动器字符串信息长度

    616. int DSLength = GetLogicalDriveStrings(0, NULL);

    617.  
    618. CHAR* DStr = new CHAR[DSLength];

    619. memset(DStr, 0, DSLength);

    620.  
    621. //通过GetLogicalDriveStrings将字符串信息复制到堆区数组中,其中保存了所有驱动器的信息。

    622. GetLogicalDriveStrings(DSLength, DStr);

    623.  
    624. int DType;

    625. int si = 0;

    626. BOOL fResult;

    627. unsigned _int64 i64FreeBytesToCaller;

    628. unsigned _int64 i64TotalBytes;

    629. unsigned _int64 i64FreeBytes;

    630.  
    631. //读取各驱动器信息,由于DStr内部数据格式是A:\NULLB:\NULLC:\NULL,所以DSLength/4可以获得具体大循环范围

    632. for (int i = 0; i<DSLength / 4; ++i)

    633. {

    634. Sleep(10);

    635. CString strdriver = DStr + i * 4;

    636. CString strTmp, strTotalBytes, strFreeBytes;

    637. DType = GetDriveType(strdriver);//GetDriveType函数,可以获取驱动器类型,参数为驱动器的根目录

    638. switch (DType)

    639. {

    640. case DRIVE_FIXED:

    641. {

    642. strTmp.Format(_T("本地磁盘"));

    643. }

    644. break;

    645. case DRIVE_CDROM:

    646. {

    647. strTmp.Format(_T("DVD驱动器"));

    648. }

    649. break;

    650. case DRIVE_REMOVABLE:

    651. {

    652. strTmp.Format(_T("可移动磁盘"));

    653. }

    654. break;

    655. case DRIVE_REMOTE:

    656. {

    657. strTmp.Format(_T("网络磁盘"));

    658. }

    659. break;

    660. case DRIVE_RAMDISK:

    661. {

    662. strTmp.Format(_T("虚拟RAM磁盘"));

    663. }

    664. break;

    665. case DRIVE_UNKNOWN:

    666. {

    667. strTmp.Format(_T("虚拟RAM未知设备"));

    668. }

    669. break;

    670. default:

    671. strTmp.Format(_T("未知设备"));

    672. break;

    673. }

    674.  
    675. //GetDiskFreeSpaceEx函数,可以获取驱动器磁盘的空间状态,函数返回的是个BOOL类型数据

    676. fResult = GetDiskFreeSpaceEx(strdriver,

    677. (PULARGE_INTEGER)&i64FreeBytesToCaller,

    678. (PULARGE_INTEGER)&i64TotalBytes,

    679. (PULARGE_INTEGER)&i64FreeBytes);

    680.  
    681. if (fResult)

    682. {

    683. strTotalBytes.Format(_T("磁盘总容量%.2fMB"), (float)i64TotalBytes / 1024 / 1024);

    684. strFreeBytes.Format(_T("磁盘剩余空间%.2fMB"), (float)i64FreeBytesToCaller / 1024 / 1024);

    685. }

    686. else

    687. {

    688. strTotalBytes.Format(_T(""));

    689. strFreeBytes.Format(_T(""));

    690. }

    691. chDriveInfo[i] = strTmp + _T("(") + strdriver + _T("):") + strTotalBytes + ", " +strFreeBytes;

    692. si += 4;

    693. }

    694. }

    695.  
    696.  
    697. /******************************************************************************

    698.  
    699. * Function: get disk's physical number from its drive letter

    700. 根据逻辑盘符找到物理硬盘号

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

    703.  
    704. * input: letter, drive letter

    705.  
    706. * output: N/A

    707.  
    708. * return: Succeed, disk number

    709.  
    710. * Fail, -1

    711.  
    712. ******************************************************************************/

    713.  
    714. //根据逻辑盘符找到物理硬盘号

    715. DWORD CMDiskManager::GetPhysicalDriveFromPartitionLetter(CHAR letter)

    716. {

    717. HANDLE hDevice; // handle to the drive to be examined

    718.  
    719. BOOL result; // results flag

    720.  
    721. DWORD readed; // discard results

    722.  
    723. STORAGE_DEVICE_NUMBER number; //use this to get disk numbers

    724.  
    725. CHAR path[256];

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

    728.  
    729. hDevice = CreateFile(path, // drive to open

    730.  
    731. GENERIC_READ | GENERIC_WRITE, // access to the drive

    732.  
    733. FILE_SHARE_READ | FILE_SHARE_WRITE, //share mode

    734.  
    735. NULL, // default security attributes

    736.  
    737. OPEN_EXISTING, // disposition

    738.  
    739. 0, // file attributes

    740.  
    741. NULL); // do not copy file attribute

    742.  
    743. if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive

    744.  
    745. {

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

    748.  
    749. return DWORD(-1);

    750. }

    751.  
    752. result = DeviceIoControl(

    753.  
    754. hDevice, // handle to device

    755.  
    756. IOCTL_STORAGE_GET_DEVICE_NUMBER, // dwIoControlCode

    757.  
    758. NULL, // lpInBuffer

    759.  
    760. 0, // nInBufferSize

    761.  
    762. &number, // output buffer

    763.  
    764. sizeof(number), // size of output buffer

    765.  
    766. &readed, // number of bytes returned

    767.  
    768. NULL // OVERLAPPED structure

    769.  
    770. );

    771.  
    772. if (!result) // fail

    773. {

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

    776.  
    777. (void)CloseHandle(hDevice);

    778.  
    779. return (DWORD)-1;

    780. }

    781.  
    782. //printf("%d %d %d\n\n", number.DeviceType, number.DeviceNumber, number.PartitionNumber);

    783.  
    784. (void)CloseHandle(hDevice);

    785.  
    786. return number.DeviceNumber;

    787.  
    788. }

    789.  
    790. /******************************************************************************

    791.  
    792. * Function: get disk's drive letters from physical number

    793. 获取一个物理硬盘上的所有盘符

    794. * e.g. 0-->{C, D, E} (disk0 has 3 drives, C:, D: and E:)

    795.  
    796. * input: vDiskNo, disk's physical number

    797.  
    798. * output: letters, letters array

    799.  
    800. * return: Succeed, the amount of letters

    801.  
    802. * Fail, -1

    803.  
    804. ******************************************************************************/

    805.  
    806. CString CMDiskManager::GetPartitionLetterFromPhysicalDrive(DWORD vDiskNo)

    807. {

    808. DWORD mask;

    809. DWORD driveType;

    810. DWORD bmLetters;

    811. DWORD diskNumber;

    812. CHAR path[256];

    813. CHAR letter;

    814. DWORD letterNum;

    815. WORD i;

    816. CHAR *p;

    817. CString tRet = "";

    818.  
    819. bmLetters = GetLogicalDrives();

    820.  
    821. if (0 == bmLetters)

    822. {

    823. return "";

    824. }

    825.  
    826. letterNum = 0;

    827.  
    828. for (i = 0; i < sizeof(DWORD) * 8; i++)

    829. {

    830. mask = 0x1u << i;

    831.  
    832. if ((mask & bmLetters) == 0) //get one letter

    833. {

    834. continue;

    835. }

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

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

    840.  
    841. driveType = GetDriveType(path);

    842.  
    843. if (driveType != DRIVE_FIXED)

    844. {

    845. bmLetters &= ~mask; //clear this bit

    846. continue;

    847. }

    848.  
    849. diskNumber = GetPhysicalDriveFromPartitionLetter(letter);

    850.  
    851. if (diskNumber != vDiskNo)

    852. {

    853. bmLetters &= ~mask; //clear this bit

    854.  
    855. continue;

    856. }

    857.  
    858. letterNum++;

    859. }

    860.  
    861. //build the result

    862.  
    863. /*letters = (CHAR *)malloc(letterNum);

    864.  
    865. if (NULL == *letters)

    866. {

    867. return (DWORD)-1;

    868. }

    869.  
    870. p = *letters;

    871. */

    872. CString s;

    873. for (i = 0; i < sizeof(DWORD) * 8; i++)

    874. {

    875. mask = 0x1u << i;

    876.  
    877. if ((mask & bmLetters) == 0)

    878. {

    879. continue;

    880. }

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

    883. s.Format("%c", letter);

    884. if (!tRet.IsEmpty()){

    885. tRet += ",";

    886. }

    887. tRet += s + ":";

    888.  
    889. }

    890.  
    891. return tRet;

    892. }


     

     

    头文件:CMDiskManager.h

     
    1. #include <windows.h>

    2. #include <winioctl.h>

    3. #include <stdio.h>

    4. #include "time.h"

    5.  
    6. #include <stdlib.h>

    7. #include <tchar.h>

    8.  
    9. #pragma pack(1)

    10.  
    11. #define MAX_MBR_PARTITIONS 4

    12. #define MBR_DISK_SIGNATURE_OFFSET 440

    13. #define MBR_DISK_PPT_OFFSET 446

    14. #define MBR_SIGNATURE_OFFSET 510

    15.  
    16. //

    17. // MBR Partition Entry

    18. //

    19. typedef struct {

    20. UINT8 BootIndicator;

    21. UINT8 StartHead;

    22. UINT8 StartSector;

    23. UINT8 StartTrack;

    24. UINT8 OSType;

    25. UINT8 EndHead;

    26. UINT8 EndSector;

    27. UINT8 EndTrack;

    28. UINT32 StartingLBA;

    29. UINT32 SizeInLBA;

    30. } MBR_PARTITION_RECORD;

    31.  
    32. //

    33. // MBR Partition table

    34. //

    35. typedef struct {

    36. UINT8 BootCode[440];

    37. UINT32 UniqueMbrSignature;

    38. UINT16 Unknown;

    39. MBR_PARTITION_RECORD PartitionRecord[MAX_MBR_PARTITIONS];

    40. UINT16 Signature;

    41. } MASTER_BOOT_RECORD;

    42.  
    43. #pragma pack()

    44.  
    45. #define MBR_SIGNATURE 0xAA55

    46. #define EXTENDED_DOS_PARTITION 0x05

    47. #define EXTENDED_WINDOWS_PARTITION 0x0F

    48.  
    49.  
    50. class CMDiskManager {

    51.  
    52. public:

    53.  
    54. CMDiskManager();

    55.  
    56. //获取磁盘几何

    57. BOOL GetDriveGeometry(DWORD vDiskNo, DISK_GEOMETRY *pdg);

    58.  
    59. //获取磁盘大小,单位是MB

    60. int GetDiskSize(DWORD vDiskNo);

    61.  
    62. /*

    63. 获取磁盘分区信息

    64. vDiskNo:磁盘序号

    65. */

    66. DWORD GetLayoutInfo(DWORD vDiskNo);

    67.  
    68. //读MBR信息

    69. BOOL ReadMBR(int vDiskNo, LPVOID *pBuffer);

    70.  
    71. /*

    72. 获取磁盘分区个数

    73. vDiskNo:磁盘序号

    74. */

    75. int GetPartNum(DWORD vDiskNo);

    76.  
    77. /*

    78. 初始化磁盘,创建分区

    79. vDiskNo:磁盘序号,千万要避开系统盘,系统盘一般是0

    80. vPartNum:分区数,只要1个分区就可以了

    81. */

    82. DWORD CreateDisk(DWORD vDiskNo, WORD vPartNum);

    83.  
    84. /*

    85. 回复磁盘到空白状态,删除MBR分区信息

    86. */

    87. DWORD DestroyDisk(DWORD vDiskNo);

    88.  
    89. };


    如果CreateDisk之后文件系统格式还是RAW的,那么可以用这个:

     
    1. /******************************************************************************

    2. * Function:快速格式化某个磁盘,文件系统NTFS

    3. * input: disk, disk name

    4. * output: N/A

    5. * return: Succeed, 0

    6. * Fail, 1

    7. ******************************************************************************/

    8. DWORD CMDiskManager::FormatVolume(CHAR letter)

    9. {

    10. DWORD ret;

    11. CHAR cmd[64];

    12. sprintf(cmd, "format %c: /FS:NTFS /Q /Y", letter);

    13. ret = (DWORD)system(cmd);

    14. return ret;

    15. }

    展开全文
  • 360安全卫士LSP修复工具修复Winsock LSP:恢复Winsock LSP到初始状态,或进入360安装目录,找到WinSockLSP.reg和WinSockLSPIFSL.reg两个文件双击执行。 运行cmd.exe,在命名提示符下执行:  1 netsh ...

    运行regedit,在注册表编辑器中,找到以下注册表项,右键单击每一项,然后单击“删除”:

    1 HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Winsock 
    2 HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Winsock2

    360安全卫士LSP修复工具修复Winsock LSP:恢复Winsock LSP到初始状态,或进入360安装目录,找到WinSockLSP.reg和WinSockLSPIFSL.reg两个文件双击执行。

    运行cmd.exe,在命名提示符下执行: 

    1 netsh winsock reset catalog
    2 netsh int ipv4 reset reset.log
    3 netsh int ipv6 reset reset.log
    4 shutdown /r /t 0

    安装 TCP/IP

     1 右键单击网络连接
     2 单击“属性”
     3 单击“安装”
     4 单击“协议”
     5 单击“添加”
     6 单击“从磁盘安装”
     7 键入C:\Windows\inf
     8 单击“确定”
     9 在可用协议列表中,单击“Internet 协议 (TCP/IP)”,然后单击“确定”
    10 重新启动计算机

    重启电脑

    1 启动DHCP client服务并设置为自动
    2 启动Network Location Awareness服务并设置为自动
    3 启动System Event Notification Service服务

    自动修复工具:http://dl.360safe.com/netfix.exe

    来自:http://lsxxycn.blog.163.com/blog/static/1881706520103645556545/
    https://zhidao.baidu.com/question/1514912767031019460.html
    https://wap.zol.com.cn/ask/x_3637903.html

    转载于:https://www.cnblogs.com/784040932/p/netsh-winsock-reset-catalog-10107.html

    展开全文
  • Linux初始RAM磁盘介绍

    千次阅读 2011-08-01 20:49:21
     初始 RAM 磁盘(initrd)是在实际根文件系统可用之前挂载到系统中的一个初始根文件系统。initrd 与内核绑定在一起,并作为内核引导过程的一部分进行加载。内核然后会将这个 initrd 文件作为其两阶段引导过程的一...
        本文转自IBM developerWorks,有稍许的改动。 
    
        1、什么是初始RAM磁盘
        初始 RAM 磁盘(initrd)是在实际根文件系统可用之前挂载到系统中的一个初始根文件系统。initrd 与内核绑定在一起,并作为内核引导过程的一部分进行加载。内核然后会将这个 initrd 文件作为其两阶段引导过程的一部分来加载模块,这样才能稍后使用真正的文件系统,并挂载实际的根文件系统。
        initrd 中包含了实现这个目标所需要的目录和可执行程序的最小集合,例如将内核模块加载到内核中所使用的 insmod 工具。
        在桌面或服务器Linux系统中,initrd是一个临时的文件系统。其生存周期很短,只会用作到真实文件系统的一个桥梁。在没有存储设备的嵌入式系统中,initrd是永久的根文件系统。
        initrd 映像中包含了支持 Linux 系统两阶段引导过程所需要的必要可执行程序和系统文件。
        根据我们运行的 Linux 的版本不同,创建初始 RAM 磁盘的方法也可能会有所不同。在 Fedora Core 3 之前,initrd 是使用 loop 设备 来构建的。loop 设备是一个设备驱动程序,利用它可以将文件作为一个块设备挂载到系统中,然后就可以查看这个文件系统中的内容了。在您的内核中可能并没有 loop 设备,不过这可以通过内核配置工具(make menuconfig)选择 Device Drivers > Block Devices > Loopback Device Support 来启用。我们可以按照下面的方法来查看 loop 设备的内容(initrd 文件的名字可能会稍有不同):

    清单 1. 查看 initrd 的内容(适用于 FC3 之前的版本)

    # mkdir temp ; cd temp
    # cp /boot/initrd.img.gz .
    # gunzip initrd.img.gz
    # mount -t ext -o loop initrd.img /mnt/initrd
    # ls -la /mnt/initrd
    #
        现在我们就可以查看 /mnt/initrd 子目录中的内容了,这就代表了 initrd 文件的内容。注意,即使您的 initrd 映像文件不是以 .gz 结尾,它也可能是一个压缩文件,您可以给这个文件添加上 .gz 后缀,然后再使用 gunzip 对其进行解压。
        从 Fedora Core 3 开始,默认的 initrd 映像变成了一个经过压缩的 cpio 归档文件。我们不用再使用 loop 设备来将 initrd 作为压缩映像进行挂载,而是可以将其作为 cpio 归档文件来使用。要查看 cpio 归档文件的内容,可以使用下面的命令:
    清单 2. 查看 initrd 的内容(适用于 FC3 及其以后的版本)

    # mkdir temp ; cd temp
    # cp /boot/initrd-2.6.14.2.img initrd-2.6.14.2.img.gz
    # gunzip initrd-2.6.14.2.img.gz
    # cpio -i --make-directories < initrd-2.6.14.2.img
    #
        结果会生成一个很小的根文件系统,如清单 3 所示。在 ./bin 目录中有一组很少但却非常必要的应用程序,包括 nash(即 not a shell,是一个脚本解释器)、insmod(用来加载内核模块)和 lvm(逻辑卷管理工具)。
    清单 3. 默认的 Linux initrd 目录结构

    # ls -la
    #
    drwxr-xr-x  10 root root    4096 May 7 02:48 .
    drwxr-x---  15 root root    4096 May 7 00:54 ..
    drwxr-xr-x  2  root root    4096 May 7 02:48 bin
    drwxr-xr-x  2  root root    4096 May 7 02:48 dev
    drwxr-xr-x  4  root root    4096 May 7 02:48 etc
    -rwxr-xr-x  1  root root     812 May 7 02:48 init
    -rw-r--r--  1  root root 1723392 May 7 02:45 initrd-2.6.14.2.img
    drwxr-xr-x  2  root root    4096 May 7 02:48 lib
    drwxr-xr-x  2  root root    4096 May 7 02:48 loopfs
    drwxr-xr-x  2  root root    4096 May 7 02:48 proc
    lrwxrwxrwx  1  root root       3 May 7 02:48 sbin -> bin
    drwxr-xr-x  2  root root    4096 May 7 02:48 sys
    drwxr-xr-x  2  root root    4096 May 7 02:48 sysroot
    #
        清单 3 中比较有趣的是 init 文件就在根目录中。与传统的 Linux 引导过程类似,这个文件也是在将 initrd 映像解压到 RAM 磁盘中时被调用的。
        这里通过使用cpio 命令,可以对 cpio 文件进行操作。cpio 是一种文件格式,它简单地使用文件头将一组文件串接在一起。cpio 文件格式可以使用 ASCII 和二进制文件。为了保证可移植性,我们可以使用 ASCII 格式。为了减小文件大小,我们可以使用二进制的版本。
        下面让我们回到最开始,来看一下 initrd 映像最初是如何构建的。对于传统的 Linux 系统来说,initrd 映像是在 Linux 构建过程中创建的。有很多工具,例如 mkinitrd,都可以用来使用必要的库和模块自动构建 initrd,从而用作与真实的根文件系统之间的桥梁。mkinitrd 工具实际上就是一个 shell 脚本,因此我们可以看到它究竟是如何来实现这个结果的。还有一个 YAIRD(即 Yet Another Mkinitrd)工具,可以对 initrd 构建过程的各个方面进行定制。
         2、手工构建定制的初始 RAM 磁盘
        由于在很多基于 Linux 的嵌入式系统上没有硬盘,因此 initrd 也会作为这种系统上的永久根文件系统使用。清单 4 显示了如何创建一个 initrd 映像文件。我使用了一个标准的 Linux 桌面,这样您即使没有嵌入式平台,也可以按照下面的步骤来执行了。除了交叉编译,其他概念(也适用于 initrd 的构建)对于嵌入式平台都是相同的。
    清单 4. 创建定制 initrd 的工具(mkird)

    #!/bin/bash
    
    # Housekeeping...
    rm -f /tmp/ramdisk.img
    rm -f /tmp/ramdisk.img.gz
    
    # Ramdisk Constants
    RDSIZE=4000
    BLKSIZE=1024
    
    # Create an empty ramdisk image
    dd if=/dev/zero of=/tmp/ramdisk.img bs=$BLKSIZE count=$RDSIZE
    
    # Make it an ext2 mountable file system
    /sbin/mke2fs -F -m 0 -b $BLKSIZE /tmp/ramdisk.img $RDSIZE
    
    # Mount it so that we can populate
    mount /tmp/ramdisk.img /mnt/initrd -t ext2 -o loop=/dev/loop0
    
    # Populate the filesystem (subdirectories)
    mkdir /mnt/initrd/bin
    mkdir /mnt/initrd/sys
    mkdir /mnt/initrd/dev
    mkdir /mnt/initrd/proc
    
    # Grab busybox and create the symbolic links
    pushd /mnt/initrd/bin
    cp /usr/local/src/busybox-1.1.1/busybox .
    ln -s busybox ash
    ln -s busybox mount
    ln -s busybox echo
    ln -s busybox ls
    ln -s busybox cat
    ln -s busybox ps
    ln -s busybox dmesg
    ln -s busybox sysctl
    popd
    
    # Grab the necessary dev files
    cp -a /dev/console /mnt/initrd/dev
    cp -a /dev/ramdisk /mnt/initrd/dev
    cp -a /dev/ram0 /mnt/initrd/dev
    cp -a /dev/null /mnt/initrd/dev
    cp -a /dev/tty1 /mnt/initrd/dev
    cp -a /dev/tty2 /mnt/initrd/dev
    
    # Equate sbin with bin
    pushd /mnt/initrd
    ln -s bin sbin
    popd
    
    # Create the init file
    cat >> /mnt/initrd/linuxrc << EOF
    #!/bin/ash
    echo
    echo "Simple initrd is active"
    echo
    mount -t proc /proc /proc
    mount -t sysfs none /sys
    /bin/ash --login
    EOF
    
    chmod +x /mnt/initrd/linuxrc
    
    # Finish up...
    umount /mnt/initrd
    gzip -9 /tmp/ramdisk.img
    cp /tmp/ramdisk.img.gz /boot/ramdisk.img.gz
        为了创建 initrd,我们最开始创建了一个空文件,这使用了 /dev/zero(一个由零组成的码流)作为输入,并将其写入到 ramdisk.img 文件中。所生成的文件大小是 4MB(4000 个 1K 大小的块)。然后使用 mke2fs 命令在这个空文件上创建了一个 ext2(即 second extended)文件系统。现在这个文件变成了一个 ext2 格式的文件系统,我们使用 loop 设备将这个文件挂载到 /mnt/initrd 上了。在这个挂载点上,我们现在就有了一个目录,它以 ext2 文件系统的形式呈现出来,我们可以对自己的 initrd 文件进行拼装了。接下来的脚本提供了这种功能。
        下一个步骤是创建构成根文件系统所需要的子目录:/bin、/sys、/dev 和 /proc。这里只列出了所需要的目录(例如没有库),但是其中包含了很多功能。
        为了可以使用根文件系统,我们使用了 BusyBox。这个工具是一个单一映像,其中包含了很多在 Linux 系统上通常可以找到的工具(例如 ash、awk、sed、insmod 等)。BusyBox 的优点是它将很多工具打包成一个文件,同时还可以共享它们的通用元素,这样可以极大地减少映像文件的大小。这对于嵌入式系统来说非常理想。将 BusyBox 映像从自己的源目录中拷贝到自己根目录下的 /bin 目录中。然后创建了很多符号链接,它们都指向 BusyBox 工具。BusyBox 会判断所调用的是哪个工具,并执行这个工具的功能。我们在这个目录中创建了几个链接来支持 init 脚本(每个命令都是一个指向 BusyBox 的链接。)
        下一个步骤是创建几个特殊的设备文件。我从自己当前的 /dev 子目录中直接拷贝了这些文件,这使用了 -a 选项(归档)来保留它们的属性。
        倒数第二个步骤是生成 linuxrc 文件。在内核挂载 RAM 磁盘之后,它会查找 init 文件来执行。如果没有找到 init 文件,内核就会调用 linuxrc 文件作为自己的启动脚本。我们在这个文件中实现对环境的基本设置,例如挂载 /proc 文件系统。除了 /proc 之外,我还挂载了 /sys 文件系统,并向终端打印一条消息。最后,我们调用了 ash(一个 Bourne Shell 的克隆),这样就可以与根文件系统进行交互了。linuxrc 文件然后使用 chmod 命令修改成可执行的。
        最后,我们的根文件系统就完成了。我们将其卸载掉,然后使用 gzip 对其进行压缩。所生成的文件(ramdisk.img.gz)被拷贝到 /boot 子目录中,这样就可以通过 GNU GRUB 对其进行加载了。
        要构建初始 RAM 磁盘,我们可以简单地调用 mkird,这样就会自动创建这个映像文件,并将其拷贝到 /boot 目录中。
        ext2 文件系统的替代品:尽管 ext2 是一种通用的 Linux 文件系统格式,但是还有一些替代品可以减小 initrd 映像文件以及所挂载上来的文件系统的大小。这种文件系统的例子有 romfs(ROM 文件系统)、cramfs(压缩 ROM 文件系统)和 squashfs(高度压缩只读文件系统)。如果我们需要暂时将数据写入文件系统中,ext2 可以很好地实现这种功能。最后,e2compr 是 ext2 文件系统驱动程序的一个扩展,可以支持在线压缩。
        3、测试定制的初始 RAM 磁盘
        Linux 内核中对 initrd 的支持: 对于 Linux 内核来说,要支持初始 RAM 磁盘,内核必须要使用 CONFIG_BLK_DEV_RAM 和 CONFIG_BLK_DEV_INITRD 选项进行编译。
        新的 initrd 映像现在已经在 /boot 目录中了,因此下一个步骤是使用默认的内核来对其进行测试。现在我们可以重新启动 Linux 系统了。在出现 GRUB 界面时,按 C 键启动 GRUB 中的命令行工具。我们现在可以与 GRUB 进行交互,从而定义要加载哪个内核和 initrd 映像文件。kernel 命令让我们可以指定内核文件,initrd 命令可以用来指定 initrd 映像文件。在定义好这些参数之后,就可以使用 boot 命令来引导内核了,如清单 5 所示。
    清单 5. 使用 GRUB 手工引导内核和 initrd
        GNU GRUB  version 0.95  (638K lower / 97216K upper memory)
    
    [ Minimal BASH-like line editing is supported. For the first word, TAB
      lists possible command completions. Anywhere else TAB lists the possible
      completions of a device/filename. ESC at any time exits.]
    
    grub> kernel /bzImage-2.6.1
       [Linux-bzImage, setup=0x1400, size=0x29672e]
    
    grub> initrd /ramdisk.img.gz
       [Linux-initrd @ 0x5f2a000, 0xb5108 bytes]
    
    grub> boot
    
    Uncompressing Linux... OK, booting the kernel.
        在内核启动之后,它会检查是否有 initrd 映像文件可用(稍后会更详细介绍),然后将其加载,并将其挂载成根文件系统。在清单 6 中我们可以看到这个 Linux 启动过程最后的样子。在启动之后,ash shell 就可以用来输入命令了。在这个例子中,我们将浏览一下根文件系统的内容,并查看一下虚拟 proc 文件系统中的内容。我们还展示了如何通过 touch 命令在文件系统中创建文件。注意所创建的第一个进程是 linuxrc(通常都是 init)。
    清单 6. 使用简单的 initrd 引导 Linux 内核

    ...
    md: Autodetecting RAID arrays
    md: autorun
    md: ... autorun DONE.
    RAMDISK: Compressed image found at block 0
    VFS: Mounted root (ext2 file system).
    Freeing unused kernel memory: 208k freed
    / $ ls
    bin         etc       linuxrc       proc        sys
    dev         lib       lost+found    sbin
    / $ cat /proc/1/cmdline
    /bin/ash/linuxrc
    / $ cd bin
    /bin $ ls
    ash      cat      echo     mount    sysctl
    busybox  dmesg    ls       ps
    /bin $ touch zfile
    /bin $ ls
    ash      cat      echo     mount    sysctl
    busybox  dmesg    ls       ps       zfile
        4、使用初始 RAM 磁盘来引导系统
        现在我们已经了解了如何构建并使用定制的初始 RAM 磁盘,本节将探索内核是如何识别 initrd 并将其作为根文件系统进行挂载的。我们将介绍启动链中的几个主要函数,并解释一下到底在进行什么操作。
        引导加载程序,例如 GRUB,定义了要加载的内核,并将这个内核映像以及相关的 initrd 拷贝到内存中。我们可以在 Linux 2.6.35.12内核源代码目录中的 ./init 子目录中找到很多这种功能。
        在内核和 initrd 映像被解压并拷贝到内存中之后,内核就会被调用了。它会执行不同的初始化操作,最终您会发现自己到了 init/main.c:kernel_init()(格式subdir/file:function)函数中。这个函数执行了大量的子系统初始化操作。此处会执行一个对 init/do_mounts.c:prepare_namespace() 的调用,这个函数用来准备名称空间(挂载 dev 文件系统、RAID 或 md、设备以及最后的 initrd)。加载 initrd 是通过调用 init/do_mounts_initrd.c:initrd_load() 实现的。
        initrd_load() 函数调用了 init/do_mounts_rd.c:rd_load_image(),它通过调用 init/do_mounts_rd.c:identify_ramdisk_image() 来确定要加载哪个 RAM 磁盘。这个函数会检查映像文件的 magic 号来确定它是 minux、etc2、romfs、cramfs 或 gzip 格式。在返回到 rd_load_image 之前,它还会调用 init/do_mounts_rd:crd_load()。这个函数负责为 RAM 磁盘分配空间,并计算循环冗余校验码(CRC),然后对 RAM 磁盘映像进行解压,并将其加载到内存中。现在,我们在一个适合挂载的块设备中就有了这个 initrd 映像。
        现在使用一个 init/do_mounts.c:mount_root() 调用将这个块设备挂载到根文件系统上。它会创建根设备,并调用 init/do_mounts.c:mount_block_root()。在这里调用 init/do_mounts.c:do_mount_root(),后者又会调用 fs/namespace.c:sys_mount() 来真正挂载根文件系统,然后 chdir 到这个文件系统中。这就是我们在清单 6 中所看到的熟悉消息 VFS: Mounted root (ext2 file system). 的地方。
        最后,返回到 kernel_init 函数中,我们就完成了初始的引导,系统已经启动并运行了。接着会调用main.c:init_post,它会调用 init/main.c:run_init_process。这会导致调用 kernel_execve 来启动用户空间的第一个进程,即init进程(在本例中是 /linuxrc)。linuxrc 可以是一个可执行程序,也可以是一个脚本(条件是它有脚本解释器可用)。
        这些函数的调用层次结构如清单 7 所示。尽管此处并没有列出拷贝和挂载初始 RAM 磁盘所涉及的所有函数,但是这足以为我们提供一个整体流程的粗略框架。
    清单 7. initrd 加载和挂载过程中所使用的主要函数的层次结构

    init/main.c: kernel_init       # 完成很多初始化操作,打开根文件系统中的初始控制台/dev/console(如果有的话),然后准备名称空间,最后调用用户空间的init程序,把工作交给它
    	init/do_mounts.c: prepare_namespace       # 挂载/dev文件系统、raid或md设备,然后加载ramdisk(即initrd)
    		init/do_mounts_initrd.c: initrd_load    # 把initrd数据加载到块设备/dev/ram0中
    			init/do_mounts_rd.c: rd_load_image    # 加载具体的initrd映像,一般是/initrd.image
    				init/do_mounts_rd.c: identify_ramdisk_image    # 确定加载哪个ramdisk,会检查映像的magic号,确定是minux, etc2, romfs或gzip格式
    				init/do_mounts_rd.c: crd_load    # 为ramdisk分配空间,并计算循环冗余校验码
    					lib/inflate.c: gunzip    # 对ramdisk进行解压
    		init/do_mounts.c: mount_root    # (返回到了prepare_namespace)把块设备挂载到根文件系统上,创建根设备/dev/root
    			init/do_mounts.c: mount_block_root
    				init/do_mounts.c: do_mount_root
    					fs/namespace.c: sys_mount     # 执行最终的挂载根文件系统动作,然后切换到这个文件系统目录中
    	init/main.c: init_post       # (返回到了kernel_init)启动init进程
    		init/main.c: run_init_process    
    			kernel_execve    # 最终启动init进程(/sbin/init, /etc/init或/bin/init)
        对于无盘引导,与嵌入式引导的情况类似,本地磁盘(软盘或 CD-ROM)对于引导内核和 ramdisk 根文件系统来说都不是必需的。DHCP(Dynamic Host Configuration Protocol)可以用来确定网络参数,例如 IP 地址和子网掩码。TFTP(Trivial File Transfer Protocol)可以用来将内核映像和初始 ramdisk 映像传输到本地设备上。传输完成之后,就可以引导 Linux 内核并挂载 initrd 了,这与本地映像引导的过程类似。    在构建嵌入式系统时,我们可能希望将 initrd 映像文件做得尽可能小,这其中有一些技巧需要考虑。首先是使用 BusyBox(本文中已经展示过了)。BusyBox 可以将数 MB 的工具压缩成几百 KB。
        在这个例子中,BusyBox 映像是静态链接的,因此它不需要其他库。然而,如果我们需要标准的 C 库(我们自己定制的二进制可能需要这个库),除了巨大的 glibc 之外,我们还有其他选择。第一个较小的库是 uClibc,这是为对空间要求非常严格的系统准备的一个标准 C 库。另外一个适合空间紧张的环境的库是 dietlib。要记住我们需要使用这些库来重新编译想在嵌入式系统中重新编译的二进制文件,因此这需要额外再做一些工作(但是这是非常值得的)
    展开全文
  • linux SD卡初始化---mmc_sd_init_card函数

    千次阅读 2015-03-27 17:03:55
    为了学习SD/SDIO协议,看了一下linux中初始化SD卡的流程,结合代码更容易SD初始化是怎么做的。 下面图截自:"SD Specifications Part 1 Physical Layer Simplified Specification Version 4.10" SD卡在sd模式下的...
  • Linux 初始 RAM 磁盘(initrd)概述

    千次阅读 2008-04-09 15:13:00
    Linux 初始 RAM 磁盘(initrd)概述 学习 initrd 的剖析
  • 硬盘的初始化

    2013-11-18 20:29:49
    硬盘的初始化:建立分区必须始终遵从的原则
  • 假设A,B两个 bean 都需要在初始化的时候从本地磁盘读取文件,其中B加载的文件,依赖A中加载的全局配置文件中配置的路径,所以需要A先于B初始化,此外A中的配置改变后也需要触发B的重新加载逻辑,所以A,B需要注入...
  • virtio-blk初始化

    千次阅读 2015-04-09 16:12:37
    对于virtio-blk设备,virtio-bus的probe回调函数会调用对应驱动的probe回调函数,这里就是virtblk_probe函数来进行初始化操作。当此函数执行完成的时候,virtio-blk相关的数据结构也就建立完成了。
  • 初始化调度程序

    千次阅读 2011-02-01 02:28:00
    5.9 初始化调度程序 回到start_kernel函数中,mm_init()执行后,所有的绝大多数内存管理的初始化都完毕,后面的代码可以开开心心的使用Linux复杂、庞大而又高效的内存管理器了。来看下一个函数,超级重点的进程...
  • MFC 六大机制 (1) MFC程序的初始化

    千次阅读 2016-06-17 15:14:23
    MFC六大机制之一(也成为MFC六大关键技术) MFC程序的初始化 本章将先介绍 MFC 的文档/视图结构,讲解实现该结构的数据结构,然后编写一个控制台应用程序来模拟 MFC 的初始化,理清 MFC 初始化的顺序,然后说明如何...
  • redis源码分析(1)——初始化

    千次阅读 2015-01-13 23:05:16
    redis源码分析,介绍redis的初始化及启动过程
  • C语言静态变量初始化问题

    千次阅读 2018-02-10 12:45:45
     这是一行很正常的代码,但是我“细心”的发现作者在使用它的时候并没有初始化。书上的解释是,用static修饰的变量会自动初始化。  为什么会被初始化呢?首先我们看一段话: 可执行程序和内存映像的区别在于:可...
  • 关于fatfs初始化

    千次阅读 2013-09-07 14:27:28
    最近看了SD卡和fatfs相关的一些东西。 在不上文件系统的时候,我们...调用这个用就可以进行打开文件,读写等等操作了 (ps:到底是怎么初始化SD的呢)然后查找了一下SD_Init() 这个函数在我们一直的时候,以及在disk
  • 函数不正确说明这个盘的文件系统结构损坏了。在平时如果数据不重要,那么可以直接格式就能用了。但是有的时候里面的数据很重要,那么就必须先恢复出数据再格式。具体恢复方法可以看正文了解(不格式的恢复方法...
  • VixDiskLib_Init 初始化 VixDiskLib 库 VixDiskLib_Connect 连接到 virtual disk library 虚拟磁盘数据的传输方式 Transport Methods VMDK File 的访问认证和权限 Credentials and Privileges SSL 证书和安全前文...
  • nvme的初始化

    千次阅读 2017-05-12 10:09:44
    nvme 是SSD的上层协议,nvme是的...nvme的入口函数在drivers/nvme/host/pci.c 中 static int __init nvme_init(void) {  int result;  nvme_workq = alloc_workqueue("nvme", WQ_UNBOUND | WQ_MEM_RECLAIM, 0)
  • 为什么串口大9初始化会报错?

    千次阅读 2016-02-02 15:10:23
    检查代码并无异象,但原因肯定在于初始化的地方,于是对这个函数产生了怀疑   这是一个多功能的函数,可打开或创建以下对象,并返回可访问的句柄:控制台,通信资源,目录(只读打开),磁盘驱动器...
  • ArrayList初始化长度

    万次阅读 2018-07-24 11:10:19
    实际上,elementData是个动态数组,我们能通过构造函数 ArrayList(int initialCapacity)来执行它的初始容量为initialCapacity;如果通过不含参数的构造函数ArrayList()来创建 ArrayList,则elementData的容量默认是...
  • LINUX系统初始化

    万次阅读 2018-04-07 20:35:44
    内核初始化:内核会调用一系列的初始化函数去对所有的内核组件进行初始化,由start_kernel()---.....---> rest_init() ----..----> kernel_init() ----....--> init_post() ------到---> 第一个用户init进程结束。...
  • UE4 游戏模块初始化顺序

    千次阅读 2018-07-17 18:47:00
    最近看教学,有个讲解UE4初始化顺序的,记录一下。 首先创建一个Actor,Character,GameInstance,GameMode,LevelScriptActor(关卡),PlayerController。 首先看一下actor的生命周期 Actor的头文件对于生成顺序...
  • MD中的bitmap(3) - Bitmap初始化

    千次阅读 2009-08-06 11:17:00
    bitmap_create完成bitmap的初始化,该函数在磁阵启动时或者用户设置bitmap文件时被调用,主要完成bitmap从磁盘到内存的加载:1. 前面说过,bitmap文件在磁盘上可能有两个位置,分别以文件指针或者与超级块之间的...
  • 块设备的初始化

    千次阅读 2011-02-01 00:03:00
    不过这个方法的具体函数是什么呢?别着急,要弄清这个问题还需要再补充一下块设备驱动的基础知识,不然就又走不下去了。块设备驱动程序是Linux块子系统中的最底层组件。它们从I/O调度程序中获得请求,然后按要求处理...
  • Windows Api函数使用出现的错误

    千次阅读 2018-07-16 13:13:50
    信息常数 常数值 对应信息 ERROR_SUCCESS 0 操作成功完成...ERROR_INVALID_FUNCTION 1 函数不正确。 ERROR_FILE_NOT_FOUND 2 系统找不到指定的文件。 ERROR_PATH_NOT_FOUND 3 系统找不到指定的路径。 ERROR_TOO_...
  • redis启动初始化过程

    千次阅读 2018-08-11 22:11:48
    redis的执行入口函数(redis.c): 2064 /* =================================== Main! ================================ */ 2065 2066 int main(int argc, char **argv) { 2067 initServerConfig(); 2068 initS....
  • Linux初始化init系统介绍

    千次阅读 2017-04-05 01:12:27
    Linux初始化init系统最近把一个程序注册成为系统启动服务。发现Ubuntu16.04版本照比Ubuntu14.x版本不一样了 :-(。所以又去研究了一下Linux启动的问题。历史Linux 系统的 init 进程经历了两次重大的演进,传统的 ...
  • 数据初始化内部流程:bootstrap模式实现了一个特殊的语言用于解析BKI数据,语言的法语解析器会逐个token处理,遇到一个语法子句就调用相应的函数:遇到proname,创建字段属性;遇到name,创建字段类型;遇到Insert,...
  • VxWorks各部分初始化流程

    千次阅读 2016-12-25 13:48:38
    原文地址:VxWorks各部分初始化流程 作者:red_eyed_hare 一)configAll.h中定义所有定置系统配置的宏 INCLUDED SOFTWARE FACILITIES:定义了基本组件; EXCLUDED FACILITIES:定义了扩充组件,缺省不...
  • linux- main.c中的初始化

    千次阅读 2010-09-28 10:54:00
    main.c中的初始化 head.s在最后部分调用main.c中的start_kernel()函数,从而把控制权交给了它。所以启动程序从start_kernel()函数继续执行。这个函数是main.c乃至整个操作系统初始化的最重要的函数,一旦它执行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,089
精华内容 50,435
关键字:

初始化磁盘函数错误