LinuxGUI/Ventoy2Disk/Core/ventoy_disk.c

   1 /******************************************************************************
   2  * ventoy_disk.c  ---- ventoy disk
   3  * Copyright (c) 2021, longpanda <admin@ventoy.net>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 3 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <stdint.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <ctype.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <sys/types.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/stat.h>
  30 #include <sys/types.h>
  31 #include <linux/fs.h>
  32 #include <dirent.h>
  33 #include <time.h>
  34 #include <ventoy_define.h>
  35 #include <ventoy_disk.h>
  36 #include <ventoy_util.h>
  37 #include <fat_filelib.h>
  38
  39 int g_disk_num = 0;
  40 static int g_fatlib_media_fd = 0;
  41 static uint64_t g_fatlib_media_offset = 0;
  42 ventoy_disk *g_disk_list = NULL;
  43
  44 static const char *g_ventoy_dev_type_str[VTOY_DEVICE_END] =
  45 {
  46     "unknown", "scsi", "USB", "ide", "dac960",
  47     "cpqarray", "file", "ataraid", "i2o",
  48     "ubd", "dasd", "viodasd", "sx8", "dm",
  49     "xvd", "sd/mmc", "virtblk", "aoe",
  50     "md", "loopback", "nvme", "brd", "pmem"
  51 };
  52
  53 static const char * ventoy_get_dev_type_name(ventoy_dev_type type)
  54 {
  55     return (type < VTOY_DEVICE_END) ? g_ventoy_dev_type_str[type] : "unknown";
  56 }
  57
  58 static int ventoy_check_blk_major(int major, const char *type)
  59 {
  60     int flag = 0;
  61     int valid = 0;
  62     int devnum = 0;
  63     int len = 0;
  64     char line[64];
  65     char *pos = NULL;
  66     FILE *fp = NULL;
  67
  68     fp = fopen("/proc/devices", "r");
  69     if (!fp)
  70     {
  71         return 0;
  72     }
  73
  74     len = (int)strlen(type);
  75     while (fgets(line, sizeof(line), fp))
  76     {
  77         if (flag)
  78         {
  79             pos = strchr(line, ' ');
  80             if (pos)
  81             {
  82                 devnum = (int)strtol(line, NULL, 10);
  83                 if (devnum == major)
  84                 {
  85                     if (strncmp(pos + 1, type, len) == 0)
  86                     {
  87                         valid = 1;
  88                     }
  89                     break;
  90                 }
  91             }
  92         }
  93         else if (strncmp(line, "Block devices:", 14) == 0)
  94         {
  95             flag = 1;
  96         }
  97     }
  98
  99     fclose(fp);
 100     return valid;
 101 }
 102
 103 static int ventoy_get_disk_devnum(const char *name, int *major, int* minor)
 104 {
 105     int rc;
 106     char *pos;
 107     char devnum[16] = {0};
 108
 109     rc = ventoy_get_sys_file_line(devnum, sizeof(devnum), "/sys/block/%s/dev", name);
 110     if (rc)
 111     {
 112         return 1;
 113     }
 114
 115     pos = strstr(devnum, ":");
 116     if (!pos)
 117     {
 118         return 1;
 119     }
 120
 121     *major = (int)strtol(devnum, NULL, 10);
 122     *minor = (int)strtol(pos + 1, NULL, 10);
 123
 124     return 0;
 125 }
 126
 127 static ventoy_dev_type ventoy_get_dev_type(const char *name, int major, int minor)
 128 {
 129     int rc;
 130     char syspath[128];
 131     char dstpath[256];
 132
 133     memset(syspath, 0, sizeof(syspath));
 134     memset(dstpath, 0, sizeof(dstpath));
 135
 136     scnprintf(syspath, "/sys/block/%s", name);
 137     rc = readlink(syspath, dstpath, sizeof(dstpath) - 1);
 138     if (rc > 0 && strstr(dstpath, "/usb"))
 139     {
 140         return VTOY_DEVICE_USB;
 141     }
 142
 143     if (SCSI_BLK_MAJOR(major) && (minor % 0x10 == 0))
 144     {
 145         return VTOY_DEVICE_SCSI;
 146     }
 147     else if (IDE_BLK_MAJOR(major) && (minor % 0x40 == 0))
 148     {
 149         return VTOY_DEVICE_IDE;
 150     }
 151     else if (major == DAC960_MAJOR && (minor % 0x8 == 0))
 152     {
 153         return VTOY_DEVICE_DAC960;
 154     }
 155     else if (major == ATARAID_MAJOR && (minor % 0x10 == 0))
 156     {
 157         return VTOY_DEVICE_ATARAID;
 158     }
 159     else if (major == AOE_MAJOR && (minor % 0x10 == 0))
 160     {
 161         return VTOY_DEVICE_AOE;
 162     }
 163     else if (major == DASD_MAJOR && (minor % 0x4 == 0))
 164     {
 165         return VTOY_DEVICE_DASD;
 166     }
 167     else if (major == VIODASD_MAJOR && (minor % 0x8 == 0))
 168     {
 169         return VTOY_DEVICE_VIODASD;
 170     }
 171     else if (SX8_BLK_MAJOR(major) && (minor % 0x20 == 0))
 172     {
 173         return VTOY_DEVICE_SX8;
 174     }
 175     else if (I2O_BLK_MAJOR(major) && (minor % 0x10 == 0))
 176     {
 177         return VTOY_DEVICE_I2O;
 178     }
 179     else if (CPQARRAY_BLK_MAJOR(major) && (minor % 0x10 == 0))
 180     {
 181         return VTOY_DEVICE_CPQARRAY;
 182     }
 183     else if (UBD_MAJOR == major && (minor % 0x10 == 0))
 184     {
 185         return VTOY_DEVICE_UBD;
 186     }
 187     else if (XVD_MAJOR == major && (minor % 0x10 == 0))
 188     {
 189         return VTOY_DEVICE_XVD;
 190     }
 191     else if (SDMMC_MAJOR == major && (minor % 0x8 == 0))
 192     {
 193         return VTOY_DEVICE_SDMMC;
 194     }
 195     else if (ventoy_check_blk_major(major, "virtblk"))
 196     {
 197         return VTOY_DEVICE_VIRTBLK;
 198     }
 199     else if (major == LOOP_MAJOR)
 200     {
 201         return VTOY_DEVICE_LOOP;
 202     }
 203     else if (major == MD_MAJOR)
 204     {
 205         return VTOY_DEVICE_MD;
 206     }
 207     else if (major == RAM_MAJOR)
 208     {
 209         return VTOY_DEVICE_RAM;
 210     }
 211     else if (strstr(name, "nvme") && ventoy_check_blk_major(major, "blkext"))
 212     {
 213         return VTOY_DEVICE_NVME;
 214     }
 215     else if (strstr(name, "pmem") && ventoy_check_blk_major(major, "blkext"))
 216     {
 217         return VTOY_DEVICE_PMEM;
 218     }
 219
 220     return VTOY_DEVICE_END;
 221 }
 222
 223 static int ventoy_is_possible_blkdev(const char *name)
 224 {
 225     if (name[0] == '.')
 226     {
 227         return 0;
 228     }
 229
 230     /* /dev/ramX */
 231     if (name[0] == 'r' && name[1] == 'a' && name[2] == 'm')
 232     {
 233         return 0;
 234     }
 235
 236     /* /dev/zramX */
 237     if (name[0] == 'z' && name[1] == 'r' && name[2] == 'a' && name[3] == 'm')
 238     {
 239         return 0;
 240     }
 241
 242     /* /dev/loopX */
 243     if (name[0] == 'l' && name[1] == 'o' && name[2] == 'o' && name[3] == 'p')
 244     {
 245         return 0;
 246     }
 247
 248     /* /dev/dm-X */
 249     if (name[0] == 'd' && name[1] == 'm' && name[2] == '-' && isdigit(name[3]))
 250     {
 251         return 0;
 252     }
 253
 254     /* /dev/srX */
 255     if (name[0] == 's' && name[1] == 'r' && isdigit(name[2]))
 256     {
 257         return 0;
 258     }
 259
 260     return 1;
 261 }
 262
 263 int ventoy_is_disk_4k_native(const char *disk)
 264 {
 265     int fd;
 266     int rc = 0;
 267     int logsector = 0;
 268     int physector = 0;
 269     char diskpath[256] = {0};
 270
 271     snprintf(diskpath, sizeof(diskpath) - 1, "/dev/%s", disk);
 272
 273     fd = open(diskpath, O_RDONLY | O_BINARY);
 274     if (fd >= 0)
 275     {
 276         ioctl(fd, BLKSSZGET, &logsector);
 277         ioctl(fd, BLKPBSZGET, &physector);
 278
 279         if (logsector == 4096 && physector == 4096)
 280         {
 281             rc = 1;
 282         }
 283         close(fd);
 284     }
 285
 286     vdebug("is 4k native disk <%s> <%d>\n", disk, rc);
 287     return rc;
 288 }
 289
 290 uint64_t ventoy_get_disk_size_in_byte(const char *disk)
 291 {
 292     int fd;
 293     int rc;
 294     unsigned long long size = 0;
 295     char diskpath[256] = {0};
 296     char sizebuf[64] = {0};
 297
 298     // Try 1: get size from sysfs
 299     snprintf(diskpath, sizeof(diskpath) - 1, "/sys/block/%s/size", disk);
 300     if (access(diskpath, F_OK) >= 0)
 301     {
 302         vdebug("get disk size from sysfs for %s\n", disk);
 303
 304         fd = open(diskpath, O_RDONLY | O_BINARY);
 305         if (fd >= 0)
 306         {
 307             read(fd, sizebuf, sizeof(sizebuf));
 308             size = strtoull(sizebuf, NULL, 10);
 309             close(fd);
 310             return (uint64_t)(size * 512);
 311         }
 312     }
 313     else
 314     {
 315         vdebug("%s not exist \n", diskpath);
 316     }
 317
 318     // Try 2: get size from ioctl
 319     snprintf(diskpath, sizeof(diskpath) - 1, "/dev/%s", disk);
 320     fd = open(diskpath, O_RDONLY);
 321     if (fd >= 0)
 322     {
 323         vdebug("get disk size from ioctl for %s\n", disk);
 324         rc = ioctl(fd, BLKGETSIZE64, &size);
 325         if (rc == -1)
 326         {
 327             size = 0;
 328             vdebug("failed to ioctl %d\n", rc);
 329         }
 330         close(fd);
 331     }
 332     else
 333     {
 334         vdebug("failed to open %s %d\n", diskpath, errno);
 335     }
 336
 337     vdebug("disk %s size %llu bytes\n", disk, size);
 338     return size;
 339 }
 340
 341 int ventoy_get_disk_vendor(const char *name, char *vendorbuf, int bufsize)
 342 {
 343     return ventoy_get_sys_file_line(vendorbuf, bufsize, "/sys/block/%s/device/vendor", name);
 344 }
 345
 346 int ventoy_get_disk_model(const char *name, char *modelbuf, int bufsize)
 347 {
 348     return ventoy_get_sys_file_line(modelbuf, bufsize, "/sys/block/%s/device/model", name);
 349 }
 350
 351 static int fatlib_media_sector_read(uint32 sector, uint8 *buffer, uint32 sector_count)
 352 {
 353     lseek(g_fatlib_media_fd, (sector + g_fatlib_media_offset) * 512ULL, SEEK_SET);
 354     read(g_fatlib_media_fd, buffer, sector_count * 512);
 355
 356     return 1;
 357 }
 358
 359 static int fatlib_is_secure_boot_enable(void)
 360 {
 361     void *flfile = NULL;
 362
 363     flfile = fl_fopen("/EFI/BOOT/grubx64_real.efi", "rb");
 364     if (flfile)
 365     {
 366         vlog("/EFI/BOOT/grubx64_real.efi find, secure boot in enabled\n");
 367         fl_fclose(flfile);
 368         return 1;
 369     }
 370     else
 371     {
 372         vlog("/EFI/BOOT/grubx64_real.efi not exist\n");
 373     }
 374
 375     return 0;
 376 }
 377
 378 static int fatlib_get_ventoy_version(char *verbuf, int bufsize)
 379 {
 380     int rc = 1;
 381     int size = 0;
 382     char *buf = NULL;
 383     char *pos = NULL;
 384     char *end = NULL;
 385     void *flfile = NULL;
 386
 387     flfile = fl_fopen("/grub/grub.cfg", "rb");
 388     if (flfile)
 389     {
 390         fl_fseek(flfile, 0, SEEK_END);
 391         size = (int)fl_ftell(flfile);
 392
 393         fl_fseek(flfile, 0, SEEK_SET);
 394
 395         buf = malloc(size + 1);
 396         if (buf)
 397         {
 398             fl_fread(buf, 1, size, flfile);
 399             buf[size] = 0;
 400
 401             pos = strstr(buf, "VENTOY_VERSION=");
 402             if (pos)
 403             {
 404                 pos += strlen("VENTOY_VERSION=");
 405                 if (*pos == '"')
 406                 {
 407                     pos++;
 408                 }
 409
 410                 end = pos;
 411                 while (*end != 0 && *end != '"' && *end != '\r' && *end != '\n')
 412                 {
 413                     end++;
 414                 }
 415
 416                 *end = 0;
 417
 418                 snprintf(verbuf, bufsize - 1, "%s", pos);
 419                 rc = 0;
 420             }
 421             free(buf);
 422         }
 423
 424         fl_fclose(flfile);
 425     }
 426     else
 427     {
 428         vdebug("No grub.cfg found\n");
 429     }
 430
 431     return rc;
 432 }
 433
 434 int ventoy_get_vtoy_data(ventoy_disk *info, int *ppartstyle)
 435 {
 436     int i;
 437     int fd;
 438     int len;
 439     int rc = 1;
 440     int ret = 1;
 441     int part_style;
 442     uint64_t part1_start_sector;
 443     uint64_t part1_sector_count;
 444     uint64_t part2_start_sector;
 445     uint64_t part2_sector_count;
 446     uint64_t preserved_space;
 447     char name[64] = {0};
 448     disk_ventoy_data *vtoy = NULL;
 449     VTOY_GPT_INFO *gpt = NULL;
 450
 451     vtoy = &(info->vtoydata);
 452     gpt = &(vtoy->gptinfo);
 453     memset(vtoy, 0, sizeof(disk_ventoy_data));
 454
 455     vdebug("ventoy_get_vtoy_data %s\n", info->disk_path);
 456
 457     if (info->size_in_byte < (2 * VTOYEFI_PART_BYTES))
 458     {
 459         vdebug("disk %s is too small %llu\n", info->disk_path, (_ull)info->size_in_byte);
 460         return 1;
 461     }
 462
 463     fd = open(info->disk_path, O_RDONLY | O_BINARY);
 464     if (fd < 0)
 465     {
 466         vdebug("failed to open %s %d\n", info->disk_path, errno);
 467         return 1;
 468     }
 469
 470     len = (int)read(fd, &(vtoy->gptinfo), sizeof(VTOY_GPT_INFO));
 471     if (len != sizeof(VTOY_GPT_INFO))
 472     {
 473         vdebug("failed to read %s %d\n", info->disk_path, errno);
 474         goto end;
 475     }
 476
 477     if (gpt->MBR.Byte55 != 0x55 || gpt->MBR.ByteAA != 0xAA)
 478     {
 479         vdebug("Invalid mbr magic 0x%x 0x%x\n", gpt->MBR.Byte55, gpt->MBR.ByteAA);
 480         goto end;
 481     }
 482
 483     if (gpt->MBR.PartTbl[0].FsFlag == 0xEE && strncmp(gpt->Head.Signature, "EFI PART", 8) == 0)
 484     {
 485         part_style = GPT_PART_STYLE;
 486         if (ppartstyle)
 487         {
 488             *ppartstyle = part_style;
 489         }
 490
 491         if (gpt->PartTbl[0].StartLBA == 0 || gpt->PartTbl[1].StartLBA == 0)
 492         {
 493             vdebug("NO ventoy efi part layout <%llu %llu>\n",
 494                 (_ull)gpt->PartTbl[0].StartLBA,
 495                 (_ull)gpt->PartTbl[1].StartLBA);
 496             goto end;
 497         }
 498
 499         for (i = 0; i < 36; i++)
 500         {
 501             name[i] = (char)(gpt->PartTbl[1].Name[i]);
 502         }
 503         if (strcmp(name, "VTOYEFI"))
 504         {
 505             vdebug("Invalid efi part2 name <%s>\n", name);
 506             goto end;
 507         }
 508
 509         part1_start_sector = gpt->PartTbl[0].StartLBA;
 510         part1_sector_count = gpt->PartTbl[0].LastLBA - part1_start_sector + 1;
 511         part2_start_sector = gpt->PartTbl[1].StartLBA;
 512         part2_sector_count = gpt->PartTbl[1].LastLBA - part2_start_sector + 1;
 513
 514         preserved_space = info->size_in_byte - (part2_start_sector + part2_sector_count + 33) * 512;
 515     }
 516     else
 517     {
 518         part_style = MBR_PART_STYLE;
 519         if (ppartstyle)
 520         {
 521             *ppartstyle = part_style;
 522         }
 523
 524         part1_start_sector = gpt->MBR.PartTbl[0].StartSectorId;
 525         part1_sector_count = gpt->MBR.PartTbl[0].SectorCount;
 526         part2_start_sector = gpt->MBR.PartTbl[1].StartSectorId;
 527         part2_sector_count = gpt->MBR.PartTbl[1].SectorCount;
 528
 529         preserved_space = info->size_in_byte - (part2_start_sector + part2_sector_count) * 512;
 530     }
 531
 532     if (part1_start_sector != VTOYIMG_PART_START_SECTOR ||
 533         part2_sector_count != VTOYEFI_PART_SECTORS ||
 534         (part1_start_sector + part1_sector_count) != part2_start_sector)
 535     {
 536         vdebug("Not valid ventoy partition layout [%llu %llu] [%llu %llu]\n",
 537                part1_start_sector, part1_sector_count, part2_start_sector, part2_sector_count);
 538         goto end;
 539     }
 540
 541     vdebug("ventoy partition layout check OK: [%llu %llu] [%llu %llu]\n",
 542                part1_start_sector, part1_sector_count, part2_start_sector, part2_sector_count);
 543
 544     vtoy->ventoy_valid = 1;
 545
 546     vdebug("now check secure boot for %s ...\n", info->disk_path);
 547
 548     g_fatlib_media_fd = fd;
 549     g_fatlib_media_offset = part2_start_sector;
 550     fl_init();
 551
 552     if (0 == fl_attach_media(fatlib_media_sector_read, NULL))
 553     {
 554         ret = fatlib_get_ventoy_version(vtoy->ventoy_ver, sizeof(vtoy->ventoy_ver));
 555         if (ret == 0 && vtoy->ventoy_ver[0])
 556         {
 557             vtoy->secure_boot_flag = fatlib_is_secure_boot_enable();
 558         }
 559         else
 560         {
 561             vdebug("fatlib_get_ventoy_version failed %d\n", ret);
 562         }
 563     }
 564     else
 565     {
 566         vdebug("fl_attach_media failed\n");
 567     }
 568
 569     fl_shutdown();
 570     g_fatlib_media_fd = -1;
 571     g_fatlib_media_offset = 0;
 572
 573     if (vtoy->ventoy_ver[0] == 0)
 574     {
 575         vtoy->ventoy_ver[0] = '?';
 576     }
 577
 578     if (0 == vtoy->ventoy_valid)
 579     {
 580         goto end;
 581     }
 582
 583     lseek(fd, 2040 * 512, SEEK_SET);
 584     read(fd, vtoy->rsvdata, sizeof(vtoy->rsvdata));
 585
 586     vtoy->preserved_space = preserved_space;
 587     vtoy->partition_style = part_style;
 588     vtoy->part2_start_sector = part2_start_sector;
 589
 590     rc = 0;
 591 end:
 592     vtoy_safe_close_fd(fd);
 593     return rc;
 594 }
 595
 596 int ventoy_get_disk_info(const char *name, ventoy_disk *info)
 597 {
 598     char vendor[64] = {0};
 599     char model[128] = {0};
 600
 601     vdebug("get disk info %s\n", name);
 602
 603     strlcpy(info->disk_name, name);
 604     scnprintf(info->disk_path, "/dev/%s", name);
 605
 606     if (strstr(name, "nvme") || strstr(name, "mmc") || strstr(name, "nbd"))
 607     {
 608         scnprintf(info->part1_name, "%sp1", name);
 609         scnprintf(info->part1_path, "/dev/%sp1", name);
 610         scnprintf(info->part2_name, "%sp2", name);
 611         scnprintf(info->part2_path, "/dev/%sp2", name);
 612     }
 613     else
 614     {
 615         scnprintf(info->part1_name, "%s1", name);
 616         scnprintf(info->part1_path, "/dev/%s1", name);
 617         scnprintf(info->part2_name, "%s2", name);
 618         scnprintf(info->part2_path, "/dev/%s2", name);
 619     }
 620
 621     info->is4kn = ventoy_is_disk_4k_native(name);
 622     info->size_in_byte = ventoy_get_disk_size_in_byte(name);
 623
 624     ventoy_get_disk_devnum(name, &info->major, &info->minor);
 625     info->type = ventoy_get_dev_type(name, info->major, info->minor);
 626     ventoy_get_disk_vendor(name, vendor, sizeof(vendor));
 627     ventoy_get_disk_model(name, model, sizeof(model));
 628
 629     scnprintf(info->human_readable_size, "%llu GB", (_ull)ventoy_get_human_readable_gb(info->size_in_byte));
 630     scnprintf(info->disk_model, "%s %s (%s)", vendor, model, ventoy_get_dev_type_name(info->type));
 631
 632     ventoy_get_vtoy_data(info, &(info->partstyle));
 633
 634     vdebug("disk:<%s %d:%d> model:<%s> size:%llu (%s)\n",
 635         info->disk_path, info->major, info->minor, info->disk_model, info->size_in_byte, info->human_readable_size);
 636
 637     if (info->vtoydata.ventoy_valid)
 638     {
 639         vdebug("%s Ventoy:<%s> %s secureboot:%d preserve:%llu\n", info->disk_path, info->vtoydata.ventoy_ver,
 640             info->vtoydata.partition_style == MBR_PART_STYLE ? "MBR" : "GPT",
 641             info->vtoydata.secure_boot_flag, (_ull)(info->vtoydata.preserved_space));
 642     }
 643     else
 644     {
 645         vdebug("%s NO Ventoy detected\n", info->disk_path);
 646     }
 647
 648     return 0;
 649 }
 650
 651 static int ventoy_disk_compare(const ventoy_disk *disk1, const ventoy_disk *disk2)
 652 {
 653     if (disk1->type == VTOY_DEVICE_USB && disk2->type == VTOY_DEVICE_USB)
 654     {
 655         return strcmp(disk1->disk_name, disk2->disk_name);
 656     }
 657     else if (disk1->type == VTOY_DEVICE_USB)
 658     {
 659         return -1;
 660     }
 661     else if (disk2->type == VTOY_DEVICE_USB)
 662     {
 663         return 1;
 664     }
 665     else
 666     {
 667         return strcmp(disk1->disk_name, disk2->disk_name);
 668     }
 669 }
 670
 671 static int ventoy_disk_sort(void)
 672 {
 673     int i, j;
 674     ventoy_disk *tmp;
 675
 676     tmp = malloc(sizeof(ventoy_disk));
 677     if (!tmp)
 678     {
 679         return 1;
 680     }
 681
 682     for (i = 0; i < g_disk_num; i++)
 683     for (j = i + 1; j < g_disk_num; j++)
 684     {
 685         if (ventoy_disk_compare(g_disk_list + i, g_disk_list + j) > 0)
 686         {
 687             memcpy(tmp, g_disk_list + i, sizeof(ventoy_disk));
 688             memcpy(g_disk_list + i, g_disk_list + j, sizeof(ventoy_disk));
 689             memcpy(g_disk_list + j, tmp, sizeof(ventoy_disk));
 690         }
 691     }
 692
 693     free(tmp);
 694     return 0;
 695 }
 696
 697 int ventoy_disk_enumerate_all(void)
 698 {
 699     int rc = 0;
 700     DIR* dir = NULL;
 701     struct dirent* p = NULL;
 702
 703     vdebug("ventoy_disk_enumerate_all\n");
 704
 705     dir = opendir("/sys/block");
 706     if (!dir)
 707     {
 708         vlog("Failed to open /sys/block %d\n", errno);
 709         return 1;
 710     }
 711
 712     while (((p = readdir(dir)) != NULL) && (g_disk_num < MAX_DISK_NUM))
 713     {
 714         if (ventoy_is_possible_blkdev(p->d_name))
 715         {
 716             memset(g_disk_list + g_disk_num, 0, sizeof(ventoy_disk));
 717             if (0 == ventoy_get_disk_info(p->d_name, g_disk_list + g_disk_num))
 718             {
 719                 g_disk_num++;
 720             }
 721         }
 722     }
 723     closedir(dir);
 724
 725     ventoy_disk_sort();
 726
 727     return rc;
 728 }
 729
 730 void ventoy_disk_dump(ventoy_disk *cur)
 731 {
 732     if (cur->vtoydata.ventoy_valid)
 733     {
 734         vdebug("%s [%s] %s\tVentoy: %s %s secureboot:%d preserve:%llu\n",
 735             cur->disk_path, cur->human_readable_size, cur->disk_model,
 736             cur->vtoydata.ventoy_ver, cur->vtoydata.partition_style == MBR_PART_STYLE ? "MBR" : "GPT",
 737             cur->vtoydata.secure_boot_flag, (_ull)(cur->vtoydata.preserved_space));
 738     }
 739     else
 740     {
 741         vdebug("%s [%s] %s\tVentoy: NA\n", cur->disk_path, cur->human_readable_size, cur->disk_model);
 742     }
 743 }
 744
 745 void ventoy_disk_dump_all(void)
 746 {
 747     int i;
 748
 749     vdebug("============= DISK DUMP ============\n");
 750     for (i = 0; i < g_disk_num; i++)
 751     {
 752         ventoy_disk_dump(g_disk_list + i);
 753     }
 754 }
 755
 756 int ventoy_disk_install(ventoy_disk *disk, void *efipartimg)
 757 {
 758     return 0;
 759 }
 760
 761
 762 int ventoy_disk_init(void)
 763 {
 764     g_disk_list = malloc(sizeof(ventoy_disk) * MAX_DISK_NUM);
 765
 766     ventoy_disk_enumerate_all();
 767     ventoy_disk_dump_all();
 768
 769     return 0;
 770 }
 771
 772 void ventoy_disk_exit(void)
 773 {
 774     check_free(g_disk_list);
 775     g_disk_list = NULL;
 776     g_disk_num  = 0;
 777 }
 778
 779