float mysqrt(float val)
{
start_count();
float x = val/10;
float dx;
float diff;
float min_tol = 0.00001f;
int i, flag;
flag = 0;
if ( val == 0 ) {
x = 0;
} else {
_Pragma("loopbound min 19 max 19")
for ( i=1; i<20; i++ ) {
if ( !flag ) {
dx = ( val - ( x*x ) ) / ( 2.0f * x );
x = x + dx;
diff = val - ( x*x );
if ( myfabs( diff ) <= min_tol )
flag = 1;
} else {
x =x;
}
}
}
return (x);
}
int main (void) {
start_count();
uint x = 21649;
uint y = 513239;
swap (&x, &y);
int result = !(prime(x) && prime(y));
end_count();
printstats(cyc_ptr_low_start, cyc_ptr_low_end);
return result;
}
int
checkfilesys(const char *fname)
{
int dosfs;
struct bootblock boot;
struct fatEntry *fat = NULL;
int i;
int mod = 0;
int quiet = 0;
int skip_fat_compare = 0;
rdonly = alwaysno;
if (!quiet)
printf("** %s", fname);
dosfs = open(fname, rdonly ? O_RDONLY : O_RDWR, 0);
if (dosfs < 0 && !rdonly) {
xlog_printf(ANDROID_LOG_INFO, FSCK_XLOG_TAG, "dosfs < 0 && !rdonly");
dosfs = open(fname, O_RDONLY, 0);
if (dosfs >= 0)
pwarn(" (NO WRITE)\n");
else if (!quiet)
printf("\n");
rdonly = 1;
} else if (!quiet)
printf("\n");
if (dosfs < 0) {
perror("Can't open");
printf("%s() : Cannot open %s\n", __func__, fname) ;
return 8;
}
if (readboot(dosfs, &boot) == FSFATAL) {
close(dosfs);
printf("\n");
return 8;
}
if (skipclean && preen && checkdirty(dosfs, &boot)) {
printf("%s: ", fname);
printf("FILESYSTEM CLEAN; SKIPPING CHECKS\n");
close(dosfs);
return 0;
}
if (((boot.FATsecs * boot.BytesPerSec) / 1024) > FAT_COMPARE_MAX_KB) {
xlog_printf(ANDROID_LOG_INFO, FSCK_XLOG_TAG, " - ((boot.FATsecs * boot.BytesPerSec) / 1024) = %d > FAT_COMPARE_MAX_KB(%d)",
((boot.FATsecs * boot.BytesPerSec) / 1024),
FAT_COMPARE_MAX_KB
);
xlog_printf(ANDROID_LOG_INFO, FSCK_XLOG_TAG, " - Skip FAT compare!") ;
skip_fat_compare = 1;
}
start_count(&fsck_p1_time) ;
if (!quiet) {
if (skip_fat_compare)
printf("** Phase 1 - Read FAT (compare skipped)\n");
else if (boot.ValidFat < 0)
printf("** Phase 1 - Read and Compare FATs\n");
else
printf("** Phase 1 - Read FAT\n");
}
mod |= readfat(dosfs, &boot, boot.ValidFat >= 0 ? boot.ValidFat : 0, &fat);
if (mod & FSERROR) {
printf("FSERROR after readfat()\n");
}
if (mod & FSFATAL) {
printf("\nFatal error during readfat()\n");
close(dosfs);
return 8;
}
if (!skip_fat_compare && boot.ValidFat < 0)
for (i = 1; i < (int)boot.FATs; i++) {
struct fatEntry *currentFat;
mod |= readfat(dosfs, &boot, i, ¤tFat);
if (mod & FSFATAL) {
printf("Fatal error during readfat() for comparison\n");
free(fat);
(void)close(dosfs);
return 8;
}
mod |= comparefat(&boot, fat, currentFat, i);
free(currentFat);
if (mod & FSFATAL) {
printf("Fatal error during FAT comparison\n");
free(fat);
(void)close(dosfs);
return 8;
}
}
end_count("Phase#1", &fsck_p1_time) ;
start_count(&fsck_p2_time) ;
if (!quiet)
printf("** Phase 2 - Check Cluster Chains\n");
mod |= checkfat(&boot, fat);
if (mod & FSERROR) {
printf("FSERROR after checkfat()\n");
}
if (mod & FSFATAL) {
printf("Fatal error during FAT check\n");
free(fat);
(void)close(dosfs);
return 8;
}
end_count("Phase#2", &fsck_p2_time) ;
/* delay writing FATs */
start_count(&fsck_p3_time) ;
if (!quiet)
printf("** Phase 3 - Checking Directories\n");
mod |= resetDosDirSection(&boot, fat);
if (mod & FSERROR) {
printf("FSERROR after resetDosDirSection()\n");
}
if (mod & FSFATAL) {
printf("Fatal error during resetDosDirSection()\n");
free(fat);
close(dosfs);
return 8;
}
/* delay writing FATs */
mod |= handleDirTree(dosfs, &boot, fat);
if (mod & FSERROR) {
printf("FSERROR after handleDirTree()\n");
/* try to recovery again */
mod &= ~FSERROR;
mod |= handleDirTree(dosfs, &boot, fat);
}
if (mod & FSFATAL) {
printf("Fatal error during handleDirTree()\n");
finishDosDirSection();
free(fat);
close(dosfs);
return 8;
}
end_count("Phase#3", &fsck_p3_time) ;
start_count(&fsck_p4_time) ;
if (!quiet)
printf("** Phase 4 - Checking for Lost Files\n");
mod |= checklost(dosfs, &boot, fat);
if (mod & FSERROR) {
printf("FSERROR after checklost()\n");
}
if (mod & FSFATAL) {
printf("Fatal error during checklost()\n");
finishDosDirSection();
free(fat);
(void)close(dosfs);
return 8;
}
end_count("Phase#4", &fsck_p4_time) ;
/* now write the FATs */
if (mod & FSFATMOD) {
if (ask(1, "Update FATs")) {
mod |= writefat(dosfs, &boot, fat, mod & FSFIXFAT);
if (mod & FSFATAL) {
printf("Fatal error during writefat()\n");
finishDosDirSection();
free(fat);
(void)close(dosfs);
return 8;
}
} else
mod |= FSERROR;
}
if (boot.NumBad)
pwarn("%d files, %d free (%d clusters), %d bad (%d clusters)\n",
boot.NumFiles,
boot.NumFree * boot.ClusterSize / 1024, boot.NumFree,
boot.NumBad * boot.ClusterSize / 1024, boot.NumBad);
else
pwarn("%d files, %d free (%d clusters)\n",
boot.NumFiles,
boot.NumFree * boot.ClusterSize / 1024, boot.NumFree);
if (mod && (mod & FSERROR) == 0) {
if (mod & FSDIRTY) {
if (ask(1, "MARK FILE SYSTEM CLEAN") == 0)
mod &= ~FSDIRTY;
if (mod & FSDIRTY) {
pwarn("MARKING FILE SYSTEM CLEAN\n");
mod |= writefat(dosfs, &boot, fat, 1);
} else {
pwarn("\n***** FILE SYSTEM IS LEFT MARKED AS DIRTY *****\n");
mod |= FSERROR; /* file system not clean */
}
}
}
finishDosDirSection();
free(fat);
(void)close(dosfs);
if (mod & FSFATAL) {
pwarn("\n***** FSFATAL *****\n");
return 8;
}
if (mod & FSERROR) {
pwarn("\n***** FSERROR *****\n");
return 8;
}
if (mod) {
pwarn("\n***** FILE SYSTEM WAS MODIFIED *****\n");
return 4;
}
return 0;
}
int
main(int argc, char **argv)
{
int ret = 0, erg;
int ch;
skipclean = 1;
debugmessage = 0;
printf("The fsck_msdos options input by caller :\n") ;
while ((ch = getopt(argc, argv, "CfFnpyd")) != -1) {
switch (ch) {
case 'C': /* for fsck_ffs compatibility */
printf(" -C\n") ;
break;
case 'f':
printf(" -f\n") ;
skipclean = 0;
break;
case 'F':
/*
* We can never run in the background. We must exit
* silently with a nonzero exit code so that fsck(8)
* can probe our support for -F. The exit code
* doesn't really matter, but we use an unusual one
* in case someone tries -F directly. The -F flag
* is intentionally left out of the usage message.
*/
printf(" -F\n") ;
exit(5);
case 'n':
alwaysno = 1;
alwaysyes = preen = 0;
printf(" -n\n") ;
break;
case 'y':
alwaysyes = 1;
alwaysno = preen = 0;
printf(" -y\n") ;
break;
case 'p':
preen = 1;
alwaysyes = alwaysno = 0;
printf(" -p\n") ;
break;
case 'd':
debugmessage = 1;
printf(" -d\n") ;
break;
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (!argc)
usage();
start_count(&fsck_total_time) ;
while (--argc >= 0) {
// setcdevname(*argv, preen);
erg = checkfilesys(*argv++);
if (erg > ret)
ret = erg;
}
end_count("Total fsck time", &fsck_total_time) ;
printf("\n=== FSCK Time Usage ===\n") ;
printf("Phase#1 tooks %lu usecs.\n", print_time(&fsck_p1_time)) ;
printf("Phase#2 tooks %lu usecs.\n", print_time(&fsck_p2_time)) ;
printf("Phase#3 tooks %lu usecs.\n", print_time(&fsck_p3_time)) ;
printf("Phase#4 tooks %lu usecs.\n", print_time(&fsck_p4_time)) ;
printf("Total fsck tooks %lu usecs.\n", print_time(&fsck_total_time)) ;
return ret;
}
