/* This function coordinates the test for each filesystem type. */
static void
test_filesystem (guestfs_h *g, const struct filesystem *fs)
{
if (fs->fs_feature && !feature_available (g, fs->fs_feature)) {
printf ("skipped test of %s because %s feature not available\n",
fs->fs_name, fs->fs_feature);
return;
}
printf ("testing charset fidelity on %s\n", fs->fs_name);
make_filesystem (g, fs);
mount_filesystem (g, fs);
test_ascii (g, fs);
if (fs->fs_8bit_only)
goto out;
if (!fs->fs_skip_latin1)
test_latin1 (g, fs);
if (!fs->fs_skip_latin2)
test_latin2 (g, fs);
test_chinese (g, fs);
out:
unmount_filesystem (g, fs);
}
/**
* initializes cpuinfo-struct
* @param print detection-summary is written to stdout when !=0
*/
void init_cpuinfo(cpu_info_t *cpuinfo,int print)
{
unsigned int i;
char output[_HW_DETECT_MAX_OUTPUT];
/* initialize data structure */
memset(cpuinfo,0,sizeof(cpu_info_t));
strcpy(cpuinfo->architecture,"unknown\0");
strcpy(cpuinfo->vendor,"unknown\0");
strcpy(cpuinfo->model_str,"unknown\0");
cpuinfo->num_cpus = num_cpus();
get_architecture(cpuinfo->architecture, sizeof(cpuinfo->architecture));
get_cpu_vendor(cpuinfo->vendor, sizeof(cpuinfo->vendor));
get_cpu_name(cpuinfo->model_str, sizeof(cpuinfo->model_str));
cpuinfo->family = get_cpu_family();
cpuinfo->model = get_cpu_model();
cpuinfo->stepping = get_cpu_stepping();
cpuinfo->num_cores_per_package = num_cores_per_package();
cpuinfo->num_threads_per_core = num_threads_per_core();
cpuinfo->num_packages = num_packages();
cpuinfo->clockrate = get_cpu_clockrate(1, 0);
/* setup supported feature list*/
if(!strcmp(cpuinfo->architecture,"x86_64")) cpuinfo->features |= X86_64;
if (feature_available("SMT")) cpuinfo->features |= SMT;
if (feature_available("FPU")) cpuinfo->features |= FPU;
if (feature_available("MMX")) cpuinfo->features |= MMX;
if (feature_available("MMX_EXT")) cpuinfo->features |= MMX_EXT;
if (feature_available("SSE")) cpuinfo->features |= SSE;
if (feature_available("SSE2")) cpuinfo->features |= SSE2;
if (feature_available("SSE3")) cpuinfo->features |= SSE3;
if (feature_available("SSSE3")) cpuinfo->features |= SSSE3;
if (feature_available("SSE4.1")) cpuinfo->features |= SSE4_1;
if (feature_available("SSE4.2")) cpuinfo->features |= SSE4_2;
if (feature_available("SSE4A")) cpuinfo->features |= SSE4A;
if (feature_available("ABM")) cpuinfo->features |= ABM;
if (feature_available("POPCNT")) cpuinfo->features |= POPCNT;
if (feature_available("AVX")) cpuinfo->features |= AVX;
if (feature_available("AVX2")) cpuinfo->features |= AVX2;
if (feature_available("FMA")) cpuinfo->features |= FMA;
if (feature_available("FMA4")) cpuinfo->features |= FMA4;
if (feature_available("AES")) cpuinfo->features |= AES;
if (feature_available("AVX512")) cpuinfo->features |= AVX512;
/* determine cache details */
for (i=0; i<(unsigned int)num_caches(0); i++)
{
cpuinfo->Cache_shared[cache_level(0,i)-1]=cache_shared(0,i);
cpuinfo->Cacheline_size[cache_level(0,i)-1]=cacheline_length(0,i);
if (cpuinfo->Cachelevels < (unsigned int)cache_level(0,i)) { cpuinfo->Cachelevels = cache_level(0,i); }
switch (cache_type(0,i))
{
case UNIFIED_CACHE: {
cpuinfo->Cache_unified[cache_level(0,i)-1]=1;
cpuinfo->U_Cache_Size[cache_level(0,i)-1]=cache_size(0,i);
cpuinfo->U_Cache_Sets[cache_level(0,i)-1]=cache_assoc(0,i);
break;
}
case DATA_CACHE: {
cpuinfo->Cache_unified[cache_level(0,i)-1]=0;
cpuinfo->D_Cache_Size[cache_level(0,i)-1]=cache_size(0,i);
cpuinfo->D_Cache_Sets[cache_level(0,i)-1]=cache_assoc(0,i);
break;
}
case INSTRUCTION_CACHE: {
cpuinfo->Cache_unified[cache_level(0,i)-1]=0;
cpuinfo->I_Cache_Size[cache_level(0,i)-1]=cache_size(0,i);
cpuinfo->I_Cache_Sets[cache_level(0,i)-1]=cache_assoc(0,i);
break;
}
default:
break;
}
}
/* print a summary */
if (print)
{
fflush(stdout);
printf("\n system summary:\n");
if(cpuinfo->num_packages) printf(" number of processors: %i\n",cpuinfo->num_packages);
if(cpuinfo->num_cores_per_package) printf(" number of cores per package: %i\n",cpuinfo->num_cores_per_package);
if(cpuinfo->num_threads_per_core) printf(" number of threads per core: %i\n",cpuinfo->num_threads_per_core);
if(cpuinfo->num_cpus) printf(" total number of threads: %i\n",cpuinfo->num_cpus);
printf("\n processor characteristics:\n");
printf(" architecture: %s\n",cpuinfo->architecture);
printf(" vendor: %s\n",cpuinfo->vendor);
printf(" processor-name: %s\n",cpuinfo->model_str);
printf(" model: Family %i, Model %i, Stepping %i\n",cpuinfo->family,cpuinfo->model,cpuinfo->stepping);
printf(" frequency: %llu MHz\n",cpuinfo->clockrate/1000000);
fflush(stdout);
printf(" supported features:\n -");
if(cpuinfo->features&X86_64) printf(" X86_64");
if(cpuinfo->features&FPU) printf(" FPU");
if(cpuinfo->features&MMX) printf(" MMX");
if(cpuinfo->features&MMX_EXT) printf(" MMX_EXT");
if(cpuinfo->features&SSE) printf(" SSE");
if(cpuinfo->features&SSE2) printf(" SSE2");
if(cpuinfo->features&SSE3) printf(" SSE3");
if(cpuinfo->features&SSSE3) printf(" SSSE3");
if(cpuinfo->features&SSE4_1) printf(" SSE4.1");
if(cpuinfo->features&SSE4_2) printf(" SSE4.2");
if(cpuinfo->features&SSE4A) printf(" SSE4A");
if(cpuinfo->features&POPCNT) printf(" POPCNT");
if(cpuinfo->features&AVX) printf(" AVX");
if(cpuinfo->features&AVX2) printf(" AVX2");
if(cpuinfo->features&AVX512) printf(" AVX512");
if(cpuinfo->features&FMA) printf(" FMA");
if(cpuinfo->features&FMA4) printf(" FMA4");
if(cpuinfo->features&AES) printf(" AES");
if(cpuinfo->features&SMT) printf(" SMT");
printf(" \n");
if(cpuinfo->Cachelevels)
{
printf(" Caches:\n");
for(i = 0; i < (unsigned int)num_caches(0); i++)
{
snprintf(output,sizeof(output),"n/a");
if (cache_info(0, i, output, sizeof(output)) != -1) printf(" - %s\n",output);
}
}
}
fflush(stdout);
}
int
main (int argc, char *argv[])
{
/* Set global program name that is not polluted with libtool artifacts. */
set_program_name (argv[0]);
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEBASEDIR);
textdomain (PACKAGE);
enum { HELP_OPTION = CHAR_MAX + 1 };
static const char *options = "a:c:d:qvVx";
static const struct option long_options[] = {
{ "add", 1, 0, 'a' },
{ "filesystem", 1, 0, 0 },
{ "format", 2, 0, 0 },
{ "help", 0, 0, HELP_OPTION },
{ "lvm", 2, 0, 0 },
{ "partition", 2, 0, 0 },
{ "verbose", 0, 0, 'v' },
{ "version", 0, 0, 'V' },
{ "wipe", 0, 0, 0 },
{ 0, 0, 0, 0 }
};
struct drv *drvs = NULL;
struct drv *drv;
const char *format = NULL;
int c;
int option_index;
int retry, retries;
g = guestfs_create ();
if (g == NULL) {
fprintf (stderr, _("guestfs_create: failed to create handle\n"));
exit (EXIT_FAILURE);
}
argv[0] = bad_cast (program_name);
for (;;) {
c = getopt_long (argc, argv, options, long_options, &option_index);
if (c == -1) break;
switch (c) {
case 0: /* options which are long only */
if (STREQ (long_options[option_index].name, "format")) {
if (!optarg || STREQ (optarg, ""))
format = NULL;
else
format = optarg;
} else if (STREQ (long_options[option_index].name, "filesystem")) {
if (STREQ (optarg, "none"))
filesystem = NULL;
else if (optarg[0] == '-') { /* eg: --filesystem --lvm */
fprintf (stderr, _("%s: no filesystem was specified\n"),
program_name);
exit (EXIT_FAILURE);
} else
filesystem = optarg;
} else if (STREQ (long_options[option_index].name, "lvm")) {
if (vg || lv) {
fprintf (stderr,
_("%s: --lvm option cannot be given multiple times\n"),
program_name);
exit (EXIT_FAILURE);
}
if (optarg == NULL) {
vg = strdup ("VG");
lv = strdup ("LV");
if (!vg || !lv) { perror ("strdup"); exit (EXIT_FAILURE); }
}
else if (STREQ (optarg, "none"))
vg = lv = NULL;
else
parse_vg_lv (optarg);
} else if (STREQ (long_options[option_index].name, "partition")) {
if (optarg == NULL)
partition = "DEFAULT";
else if (STREQ (optarg, "none"))
partition = NULL;
else
partition = optarg;
} else if (STREQ (long_options[option_index].name, "wipe")) {
wipe = 1;
} else {
fprintf (stderr, _("%s: unknown long option: %s (%d)\n"),
program_name, long_options[option_index].name, option_index);
exit (EXIT_FAILURE);
}
break;
case 'a':
OPTION_a;
break;
case 'v':
OPTION_v;
break;
case 'V':
OPTION_V;
break;
case 'x':
OPTION_x;
break;
case HELP_OPTION:
usage (EXIT_SUCCESS);
default:
usage (EXIT_FAILURE);
}
}
/* These are really constants, but they have to be variables for the
* options parsing code. Assert here that they have known-good
* values.
*/
assert (read_only == 0);
assert (inspector == 0);
assert (live == 0);
/* Must be no extra arguments on the command line. */
if (optind != argc)
usage (EXIT_FAILURE);
/* The user didn't specify any drives to format. */
if (drvs == NULL)
usage (EXIT_FAILURE);
/* Because the libguestfs kernel can get stuck rereading the
* partition table after things have been erased, we sometimes need
* to completely restart the guest. Hence this complex retry logic.
*/
for (retries = 0; retries <= 1; ++retries) {
/* Add domains/drives from the command line (for a single guest). */
add_drives (drvs, 'a');
if (guestfs_launch (g) == -1)
exit (EXIT_FAILURE);
/* Test if the wipefs API is available. */
have_wipefs = feature_available (g, "wipefs");
/* Perform the format. */
retry = do_format ();
if (!retry)
break;
if (retries == 0) {
/* We're going to silently retry, after reopening the connection. */
guestfs_h *g2;
g2 = guestfs_create ();
guestfs_set_verbose (g2, guestfs_get_verbose (g));
guestfs_set_trace (g2, guestfs_get_trace (g));
if (guestfs_shutdown (g) == -1)
exit (EXIT_FAILURE);
guestfs_close (g);
g = g2;
}
else {
/* Failed. */
fprintf (stderr,
_("%s: failed to rescan the disks after two attempts. This\n"
"may mean there is some sort of partition table or disk\n"
"data which we are unable to remove. If you think this\n"
"is a bug, please file a bug at http://libguestfs.org/\n"),
program_name);
exit (EXIT_FAILURE);
}
}
/* Free up data structures. */
free_drives (drvs);
if (guestfs_shutdown (g) == -1)
exit (EXIT_FAILURE);
guestfs_close (g);
exit (EXIT_SUCCESS);
}
