精华内容
下载资源
问答
  • 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. }

    展开全文
  • 使用ehcache时如何持久化数据磁盘,并且在应用服务器重启后不丢失数据 1、如何持久化到磁盘 ...3、系统初始化时添加 4、修改ehcache源码 另外,持久化到硬盘的对象都需要是可序列化的,用以下方法处理:
    1、如何持久化到磁盘
    使用cache.flush(),每次写入到cache后调用cache.flush() ,这样ehcache 会将索引(xxx.index)回写到磁盘。这样就不用担心程序是否非正常退出导致缓存丢失了。

    2、附上配置文件修改:

    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:noNamespaceSchemaLocation="ehcache.xsd" name="ehcache">
    	<cacheManagerPeerProviderFactory
    		class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
    		properties="peerDiscovery=manual"/>
    
    	<diskStore path="d:/ehcache"/>
    	<cache name="submitProcessInst" maxElementsInMemory="1" eternal="true"
    		overflowToDisk="true" diskSpoolBufferSizeMB="10" maxElementsOnDisk="1000000"
    		diskPersistent="true" memoryStoreEvictionPolicy="LRU">
    		<cacheEventListenerFactory
    			class="net.sf.ehcache.distribution.RMICacheReplicatorFactory" />
    		<!-- 比一般配置多了这个 -->
    		<bootstrapCacheLoaderFactory class="net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory"/>
    	</cache>
    
    </ehcache>
    注意:当不需保存数据在内存中时,将maxElementsInMemory="1",而不是0,设置为0时,可以看到ehcache有warning:
    2015-03-10 10:44:28,469 WARN  net.sf.ehcache.config.CacheConfiguration.warnMaxEntriesLocalHeap(CacheConfiguration.java:1601) - Cache: submitProcessInst has a maxElementsInMemory of 0. This might lead to performance degradation or OutOfMemoryError at Terracotta client.From Ehcache 2.0 onwards this has been changed to mean a store with no capacity limit. Set it to 1 if you want no elements cached in memory

    3、系统初始化时添加:
    System.setProperty(net.sf.ehcache.CacheManager.ENABLE_SHUTDOWN_HOOK_PROPERTY,"true");

    4、在web.xml添加listener,让应用程序关闭时通知ehcache

    	<listener>
    		<listener-class>net.sf.ehcache.constructs.web.ShutdownListener</listener-class>
    	</listener>
    

    5、修改ehcache源码,让它不会轻易删除index文件,因为index文件若删除了,cache数据就会清零。

    修改ehcache源码中的 net.sf.ehcache.store.disk.DiskStorageFactory类中的 DiskStorageFactory 方法,注释最后else if 的代码



    另外,持久化到硬盘的对象都需要是可序列化的,用以下方法处理:

    a)如果类是你自己的,把他设置成可序列化
    b)如果类中的某些属性是是第三方jar包的类,可以将它的字段设置成transient(不需序列化)
    c)如果类中的某些属性是是第三方jar包但你一定要将所有属性都序列化,可以考虑将这些属性转化成json等

    ehcache版本:ehcache-core-2.5.2.jar

    集群中使用ehcache
    http://www.ibm.com/developerworks/cn/java/j-lo-ehcache/
    http://www.cnblogs.com/yangy608/archive/2011/10/07/2200669.html

    展开全文
  • 转载自: ... ... 一现象描述 ...Delete是oracle数据库中的常用操作,尤其是在自动化测试中,初始化环境、前置准备都不可避免的进行增删操作,但持续一时间后,可能碰到表空间不足这类报错现象,这...

    转载自:

    https://www.cnblogs.com/gaoyuchuanIT/articles/4151231.html

     

    https://blog.51cto.com/2681882/2133524

    一 现象描述

    Delete是oracle数据库中的常用操作,尤其是在自动化测试中,初始化环境、前置准备都不可避免的进行增删操作,但持续一时间后,可能会碰到表空间不足这类报错现象,这就不禁纳闷儿了,明明插入数据前会有删除的,数据总量并没有呈现明显的量级变化,为什么表占用空间却在偷偷增大呢?

     

    二 现象分析

    出现上述现象的原因是Delete操作并不会释放占用的空间。在讲解原因之前,先了解下oracle中高水位线的概念,有助于理解delete操作产生的这种现象。

    所谓的高水位(HWM),通俗的讲就是一个标记,用来记录已经有多少数据块(Block)分配给表,可以拿水库的历史最高水位来类比,当使用delete操作后,数据虽然被删除了,但这个高水位的标记并没有降低,就好比水库的历史最高水位不会因为水被释放了而降低。因而,原则上在没有外部干预的条件下,这个高水位标记值只会增大,不会降低。

     

    三 实战模拟重现现象

    根据上面的现象描述和分析,接下来,我会用具体的实例模拟该现象,使大家可以更直观的了解。

    第1,创建一张测试表test,具体字段不需要关心,只要知道初始了存储空间为100M,如图所示:

    1.jpg

     

    第2,创建完成后,我们查看下数据表占用的空间,如图所示:

     2-记住三个关键数据.jpg

     

    其中,查询前需要对表进行分析,使用命令为:ANALYZE TABLE test ESTIMATE STATISTICS;查询语句为:SELECT blocks, empty_blocks, num_rows FROM user_tables WHERE table_name = 'TEST';

    注意上面三个字段的结果:BLOCKS=0;  EMPTY_BLOCKS=13312;  NUM_ROWS=0,即当前表占用的块数为0,默认1 BLOCK = 8kb,预分配的块为13312,行数为0。

    一切都没有问题,新创建的表,没有数据嘛,当然行数为0,占用块数为0喽。

     

    第3,写一个语句块,循环插入1000条语句,再次对test表进行分析、查询,结果如下:

    3插入数据.jpg

     

     

    从图中可以看到,占用BLOCKS=222,NUM_ROWS=1000,合乎逻辑,插入了1000条数据,占用了空间嘛。

     

    第4,使用Delete语句删除1000条数据,再次对test表进行分析、查询,结果却是如下:

    4删除后行数为0空间还占用.jpg

     

    从上图中可以清楚的看到,数据被删除后,NUM_ROWS=0了,但是BLOCKS并没有被置为0,也就是这部分数据块仍然被认为是占用的。

    因此,就出现了本文一开始就提到的现象,随着不断的插入、删除数据,BLOCKS也会不断扩大,尽快delete操作后,可能表中数据量很少,但表占用的存储空间未减少。

     

    四 解决方法

    针对delete操作引起的空间不释放现象,或者,更正式一点的说法,如何降低高水位线,方法有很多种,如,shrink space;move tablespace;create table xxx as select * from xxx 重建表等。使用这些方法前,我们的原则是:

    如果可以truncate,直接truncate,该操作会重置高水位线,BLOCKS会被置为0,NUM_ROWS置为0;否则,优先使用shrink space,该方法不需要重建索引。

    接着上面第4步,我们使用shrink space降低高水位线,释放空间,其中,使用shrink space命令前,需要先alter table test enable row movement;开启行移动,再次对表进行分析、查询,结果如下:

     5.jpg

     

    从图中可以看出,此时BLOCKS已经被置为0了,但是,细心的你可能也发现, EMPTY_BLOCKS已经不是初始的13312,而是此时的40,这说明shrink space不仅会释放高水位线以下的空间,也会释放申请的空间,即高水位线上下都有操作,这也是与move、truncate的不同,它们只能释放高水位线以下的空间。

     

    五 shrink space常用操作命令

    Shrink space的常用命令如下:

    alter table tablename enable row movement;--打开行移动

    alter table tablename shrink space cascade;--压缩表及相关数据段,并下调HWM

    alter table tablename shrink sapce compact;--只压缩,不下调HWM

    alter table tablename shrink sapce ;--下调HWM

    alter table tablename disable row movement;--关闭行移动

    6 常用命令.jpg

     

    六 Delete操作的潜在影响

    根据上述分析,delete操作产生的潜在影响如下:

    1. 全表扫描通常要读出直到HWM标记的所有属于该表的数据块,即使该表中没有任何数据;(造成查询变慢)

    2. 插入操作时使用append关键字,即使HWM以下有空闲的数据库块,插入时使用HWM以上的数据块;(造成HWM自动增大)

     

    七 总结

    通过上文的现象描述和分析,随着insert的不断操作,高水位线也随着不断增加,尽管delete了数据,但高水位线并没有下降,导致表占用的空间没有释放。因此,在实际应用中,如果可能,尽量使用truncate,而且该操作高效、快速;否则要考虑下delete操作遗留的影响,使用合适的方法整理空间

    展开全文
  • [磁盘阵列数据恢复故障描述]客户的一台HP DL380 G4服务器,服务器使用hp...由于服务器机房进行搬迁,搬迁过程中管理员顺便打扫了一下服务器和磁盘阵列设备,随后在新机房链接线路后服务器无法识别RAID,未做初始化。...
    [磁盘阵列数据恢复故障描述]
    客户的一台HP DL380 G4服务器,服务器使用hp smart array控制器挂载了一台国产磁盘阵列,磁盘阵列由14块146G SCSI硬盘组成一组RAID5。操作系统为LINUX,构建了NFS+FTP,作为公司内部文件服务器使用。
    由于服务器机房进行搬迁,搬迁过程中管理员顺便打扫了一下服务器和磁盘阵列设备,随后在新机房链接线路后服务器无法识别RAID,未做初始化。

    [raid数据恢复中心初检结果]

    工程师对设备进行简单的初检,发现数据丢失的原因为raid信息丢失,HP smart array系列控制器源自康柏,RAID中的冗余采用双循环的校验方式。

    [raid数据恢复步骤]

    1、先将SCSI硬盘柜直接连接到不包含有RAID功能的SCSI扩展卡上。
    2、然后工程师们在专用(windows2003改装后)的修复平台上以单盘的方式连接服务器阵列中的所有硬盘。
    3、为了保护客户原有数据,避免因数据恢复操作更改客户原始数据,在所有的数据恢复过程中都必须对所有硬盘以只读方式做完整镜像,同时镜像亦存储于带冗余保护的设备上。
    4、安排工程师从镜像文件中分析原RAID的双循环校验参数,搭建虚拟raid平台.
    5、在虚拟RAID平台去掉早离线的盘,解释文件系统,此时已经可以导出raid数据。
    6、在客户原HP 服务器上连接盘阵,重新配置RAID。

    7、最后通过网络dd、NFS、SAMBA、FTP、SSH等数据传输方法把所有数据传回新建的raid磁盘阵列中。


    [数据恢复结果]
    Raid中所有数据100%恢复成功,全部工作历时2 天。
    展开全文
  • 数据恢复步骤 查看所有磁盘状态  1> 建立与管理\磁盘管理\,确定... 2> 选择磁盘状态为"Non-initial"的磁盘,点"初始化磁盘"。 RAID磁盘重建  1> RAID管理\重建\以磁盘为主的复原\选择可用的磁盘\确定。 查看
  • 用了Mounty后移动硬盘没有初始化

    千次阅读 2017-11-16 15:32:21
    在MAC电脑用Mounty读写移动硬盘,结果插回windows电脑发现移动硬盘不能识别了,磁盘管理中显示磁盘1未知没有初始化。想要恢复里面的数据,可以看下文了解。 工具/原料 ·  极光数据恢复软件 ·  方法/步骤 ...
  •  之前我们讨论过,cache的索引在trafficserver启动时,磁盘加载到内存中。这里有两个问题。  问题1:内存中的索引被更新后,与磁盘中保存的部分已经不一致,我们称之为脏了,这时需要将索引写回至磁盘中去...
  • ogg重新初始化

    千次阅读 2015-01-21 18:27:05
    在target端因为磁盘空间满replicat ABANDING,清理磁盘空间后,再次start rep1 ,报错:找不到上一个trace文件,此时,“杀招”出现了。 alter replicat rep1 extseqno 0 extrba 0; 然后在检查点检查中一直: ...
  • Zookeeper zookeeper 初始化还原

    千次阅读 2018-10-24 16:16:36
     由于 kafka 的升级,zookeeper 残存了很多原有的消费者信息,需要进行初始化 还原 zookeeper。首先我们要清楚一点,zookeeper 服务停止后,是如何存储数据的。     zookeeper 在运行中数据加载在内存中,...
  • 1. BlockManager的注册...一:BlockManager初始化 1. BlockManager的实例对象调用initializes的时候才能正常工作。 启动initializes方法又两个作用:BlockTransferService(网络通信),ShuffleClient/** * Initializ
  • IOS 应用初始化和终止分析

    千次阅读 2012-07-28 13:26:59
    初始化和终止过程中,UIApplication类向应用程序的委托发送恰当的消息,使其执行必要的任务。虽然系统并不要求您的应用程序响应这些消息,但是,几乎所有的iPhone应用程序都应该处理这些消息。初始化是您为应用...
  • 服务器Raid 5磁盘阵列算法原理分布式奇偶校验的独立磁盘结构(也就是我们称之为的raid 5)数据恢复有一个“奇偶校验”概念需要理解。我们可以把它简单的理解成为二进制运算中的“异或运算”,通常使用的标识是xor。...
  • 当创建大数据库时,为了减少碎片,我们一般都会安装最终的使用大小创建,但是初始化数据和日志文件时覆盖以前删除的文件遗留在磁盘上的任何现有数据,花费很多的时间。  不过SQL Server 提供了即时文件初始化...
  • Kafka初始化和故障转移

    千次阅读 2017-05-31 17:19:18
    Kafka启动都会创建KafkaController,然后向zookeeper注册,第一个注册的节点就是Leader,其余都是follower。当KafkaController出现故障,不能继续管理集群,则那些KafkaController follower开始竞争成为新的Leader...
  • 数据去重的磁盘索引瓶颈

    千次阅读 2014-01-16 11:33:21
     随着数据量的不断激增,数据去重技术通过删除重复数据节省存储空间和网络传输带宽的,在数据备份系统和文档归档系统中取得了广泛地应用。企业级数据要求高吞吐率,高速的索引查询,但是数据量的增加导致的索引表的...
  • ArrayList初始化长度

    万次阅读 2018-07-24 11:10:19
    自动增长带来数据向新数组的重新拷贝,因此,如果可预知数据量的多少,可在构造ArrayList时指定其容量。在添加大量元素前,应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量,这可以减少递增式再...
  • Mysql初始化配置文件详解

    千次阅读 2016-06-09 20:49:27
    # MySQL首先扫描一遍该缓冲,以避免磁盘搜索,提高查询速度,如果需要排序大量数据,可适当调高该值。但MySQL为每个客户连接发放该缓冲空间,所以应尽量适当设置该值,以避免内存开销过大 sort_buffer_size = 8M...
  • 无损数据动态磁盘逆转为基本磁盘的简单办法
  • 目录目录 前文列表 VixDiskLib 虚拟磁盘库 VixDiskLib_Create 创建新的寄宿磁盘 Hosted Disk VixDiskLib_Clone 克隆 ...VixDiskLib_Unlink 删除 VMDK File VixDiskLib_Grow 扩展 VMDK File VixDiskLib_Shrink 压缩 VM
  • 记录OGG生产环境重新初始化

    千次阅读 2015-08-27 01:05:11
    记录OGG生产环境重新初始化 1、impdp导入产生大量的日志,需要提前检查磁盘空间大小,特别是归档日志是否保存在,如果归档空间满导致ogg复制无法启用,提示如下错误:  ERROR OGG-00664 Oracle GoldenGate ...
  • redis配置持久磁盘

    千次阅读 2019-11-13 10:33:23
    为了解决这个问题,Redis 提供了 RDB 和 AOF 两种持久方案,将内存中的数据保存到磁盘中,避免数据丢失。Redis的所有数据都是保存在内存中,然后不定期的通过异步方式保存到磁盘上(这称为“半持久模式”)...
  • Linux初始化init系统介绍

    千次阅读 2017-04-05 01:12:27
    Linux初始化init系统最近把一个程序注册成为系统启动服务。发现Ubuntu16.04版本照比Ubuntu14.x版本不一样了 :-(。所以又去研究了一下Linux启动的问题。历史Linux 系统的 init 进程经历了两次重大的演进,传统的 ...
  • redis启动初始化过程

    千次阅读 2018-08-11 22:11:48
    在定时事件处理中使用, 定时事件有可能把内存中的数据保存到磁盘, 判断的依据就是该字段的值,这里设置了三个标准, 满足其中任何一个,定时事件都会把内存数据保存到磁盘文件. 函数 initServer 的实现(redis.c):...
  • 第十章、如何给10^7个数据量的磁盘文件排序作者:July,yansha,5,编程艺术室。出处:http://blog.csdn.net/v_JULY_v 。 前奏 经过几天的痛苦沉思,最终决定,把原程序员面试题狂想曲系列正式更名为程序员编程...
  • iOS开发之缓存(一):内存缓存 iOS内存缓存和磁盘缓存的区别 iOS开发之内存缓存 磁盘缓存 沙盒
  • linux dd格式化磁盘 本文摘自Manning出版的《 Linux in Action》第4章。 无论您是试图从即将死去的存储驱动器中抢救数据,将存档备份到远程存储,还是在其他位置完美复制活动分区,您都需要了解如何安全可靠地复制...
  • 服务器虚拟化之十九 桌面虚拟化之初始化View链接服务器   当完成了vCenter服务器、View连接服务器、ViewComposer服务器的安装后,就要初始化配置View连接服务器,建立对应的关系和授权许可证给View连接服务器。 ...
  • 还有另外一种初始化方式:DbSchemaCreate方式初始化,这种方式比较费劲,需要创建一个工程,导入jar包,执行代码,这里不介绍了。 三、activiti6基于mysql的数据库 现在,我们创建好了所有的表,可以替换掉上一章节...
  • CentOS 7.6安装及初始化配置

    千次阅读 2018-12-08 10:42:33
    初始化系统配置 设置selinux 禁用selinux: [root@localhost ~]# vi /etc/selinux/config 修改内容为: SELINUX=disabled 注意: 将SELINUX=enforcing改为SELINUX=disabled 设置后需要重启才能生效 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 121,528
精华内容 48,611
关键字:

初始化磁盘会不会删除数据