#define CHAZ_USE_SHORT_NAMES
#include "Charmonizer/Core/HeaderChecker.h"
#include "Charmonizer/Core/Compiler.h"
#include "Charmonizer/Core/ConfWriter.h"
#include "Charmonizer/Core/Stat.h"
#include "Charmonizer/Core/Util.h"
#include "Charmonizer/Probe/LargeFiles.h"
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
/* Sets of symbols which might provide large file support. */
typedef struct off64_combo {
const char *includes;
const char *fopen_command;
const char *ftell_command;
const char *fseek_command;
const char *offset64_type;
} off64_combo;
static off64_combo off64_combos[] = {
{ "#include <sys/types.h>\n", "fopen64", "ftello64", "fseeko64", "off64_t" },
{ "#include <sys/types.h>\n", "fopen", "ftello64", "fseeko64", "off64_t" },
{ "#include <sys/types.h>\n", "fopen", "ftello", "fseeko", "off_t" },
{ "", "fopen", "ftell", "fseek", "off_t" },
{ "", "fopen", "_ftelli64", "_fseeki64", "__int64" },
{ "", "fopen", "ftell", "fseek", "long" },
{ NULL, NULL, NULL, NULL, NULL }
};
typedef struct unbuff_combo {
const char *includes;
const char *lseek_command;
const char *pread64_command;
} unbuff_combo;
static unbuff_combo unbuff_combos[] = {
{ "#include <unistd.h>\n#include <fcntl.h>\n", "lseek64", "pread64" },
{ "#include <unistd.h>\n#include <fcntl.h>\n", "lseek", "pread" },
{ "#include <io.h>\n#include <fcntl.h>\n", "_lseeki64", "NO_PREAD64" },
{ NULL, NULL, NULL }
};
/* Check what name 64-bit ftell, fseek go by.
*/
static chaz_bool_t
S_probe_off64(off64_combo *combo);
/* Check for a 64-bit lseek.
*/
static chaz_bool_t
S_probe_lseek(unbuff_combo *combo);
/* Check for a 64-bit pread.
*/
static chaz_bool_t
S_probe_pread64(unbuff_combo *combo);
/* Determine whether we can use sparse files.
*/
static chaz_bool_t
S_check_sparse_files();
/* Helper for check_sparse_files().
*/
static void
S_test_sparse_file(long offset, Stat *st);
/* See if trying to write a 5 GB file in a subprocess bombs out. If it
* doesn't, then the test suite can safely verify large file support.
*/
static chaz_bool_t
S_can_create_big_files();
/* Vars for holding lfs commands, once they're discovered. */
static char fopen_command[10];
static char fseek_command[10];
static char ftell_command[10];
static char lseek_command[10];
static char pread64_command[10];
static char off64_type[10];
void
LargeFiles_run(void)
{
chaz_bool_t success = false;
chaz_bool_t found_lseek = false;
chaz_bool_t found_pread64 = false;
unsigned i;
ConfWriter_start_module("LargeFiles");
/* See if off64_t and friends exist or have synonyms. */
for (i = 0; off64_combos[i].includes != NULL; i++) {
off64_combo combo = off64_combos[i];
success = S_probe_off64(&combo);
if (success) {
strcpy(fopen_command, combo.fopen_command);
strcpy(fseek_command, combo.fseek_command);
strcpy(ftell_command, combo.ftell_command);
strcpy(off64_type, combo.offset64_type);
break;
}
}
/* Write the affirmations/definitions. */
if (success) {
ConfWriter_append_conf("#define CHY_HAS_LARGE_FILE_SUPPORT\n");
/* Alias these only if they're not already provided and correct. */
if (strcmp(off64_type, "off64_t") != 0) {
ConfWriter_append_conf("#define chy_off64_t %s\n", off64_type);
ConfWriter_append_conf("#define chy_fopen64 %s\n", fopen_command);
ConfWriter_append_conf("#define chy_ftello64 %s\n", ftell_command);
ConfWriter_append_conf("#define chy_fseeko64 %s\n", fseek_command);
}
}
/* Probe for 64-bit versions of lseek and pread (if we have an off64_t). */
if (success) {
for (i = 0; unbuff_combos[i].lseek_command != NULL; i++) {
unbuff_combo combo = unbuff_combos[i];
found_lseek = S_probe_lseek(&combo);
if (found_lseek) {
strcpy(lseek_command, combo.lseek_command);
ConfWriter_append_conf("#define chy_lseek64 %s\n", lseek_command);
break;
}
}
for (i = 0; unbuff_combos[i].pread64_command != NULL; i++) {
unbuff_combo combo = unbuff_combos[i];
found_pread64 = S_probe_pread64(&combo);
if (found_pread64) {
strcpy(pread64_command, combo.pread64_command);
ConfWriter_append_conf("#define chy_pread64 %s\n", pread64_command);
found_pread64 = true;
break;
}
}
}
/* Check for sparse files. */
if (S_check_sparse_files()) {
ConfWriter_append_conf("#define CHAZ_HAS_SPARSE_FILES\n");
/* See if we can create a 5 GB file without crashing. */
if (success && S_can_create_big_files())
ConfWriter_append_conf("#define CHAZ_CAN_CREATE_BIG_FILES\n");
}
else {
ConfWriter_append_conf("#define CHAZ_NO_SPARSE_FILES\n");
}
/* Short names. */
if (success) {
ConfWriter_start_short_names();
ConfWriter_shorten_macro("HAS_LARGE_FILE_SUPPORT");
/* Alias these only if they're not already provided and correct. */
if (strcmp(off64_type, "off64_t") != 0) {
ConfWriter_shorten_typedef("off64_t");
ConfWriter_shorten_function("fopen64");
ConfWriter_shorten_function("ftello64");
ConfWriter_shorten_function("fseeko64");
}
if (found_lseek && strcmp(lseek_command, "lseek64") != 0) {
ConfWriter_shorten_function("lseek64");
}
if (found_pread64 && strcmp(pread64_command, "pread64") != 0) {
ConfWriter_shorten_function("pread64");
}
ConfWriter_end_short_names();
}
ConfWriter_end_module();
}
/* Code for checking ftello64 and friends. */
static char off64_code[] =
QUOTE( %s )
QUOTE( #include "_charm.h" )
QUOTE( int main() { )
QUOTE( %s pos; )
QUOTE( FILE *f; )
QUOTE( Charm_Setup; )
QUOTE( f = %s("_charm_off64", "w"); )
QUOTE( if (f == NULL) return -1; )
QUOTE( printf("%%d", (int)sizeof(%s)); )
QUOTE( pos = %s(stdout); )
QUOTE( %s(stdout, 0, SEEK_SET); )
QUOTE( return 0; )
QUOTE( } );
static chaz_bool_t
S_probe_off64(off64_combo *combo)
{
char *output = NULL;
size_t output_len;
size_t needed = sizeof(off64_code)
+ (2 * strlen(combo->offset64_type))
+ strlen(combo->fopen_command)
+ strlen(combo->ftell_command)
+ strlen(combo->fseek_command)
+ 20;
char *code_buf = (char*)malloc(needed);
chaz_bool_t success = false;
/* Prepare the source code. */
sprintf(code_buf, off64_code, combo->includes, combo->offset64_type,
combo->fopen_command, combo->offset64_type, combo->ftell_command,
combo->fseek_command);
/* Verify compilation and that the offset type has 8 bytes. */
output = CC_capture_output(code_buf, strlen(code_buf), &output_len);
if (output != NULL) {
long size = strtol(output, NULL, 10);
if (size == 8)
success = true;
free(output);
}
if (!Util_remove_and_verify("_charm_off64")) {
Util_die("Failed to remove '_charm_off64'");
}
return success;
}
/* Code for checking 64-bit lseek. */
static char lseek_code[] =
QUOTE( %s )
QUOTE( #include "_charm.h" )
QUOTE( int main() { )
QUOTE( int fd; )
QUOTE( Charm_Setup; )
QUOTE( fd = open("_charm_lseek", O_WRONLY | O_CREAT, 0666); )
QUOTE( if (fd == -1) { return -1; } )
QUOTE( %s(fd, 0, SEEK_SET); )
QUOTE( printf("%%d", 1); )
QUOTE( if (close(fd)) { return -1; } )
QUOTE( return 0; )
QUOTE( } );
static chaz_bool_t
S_probe_lseek(unbuff_combo *combo)
{
char *output = NULL;
size_t output_len;
size_t needed = sizeof(lseek_code) + strlen(combo->includes)
+ strlen(combo->lseek_command) + 20;
char *code_buf = (char*)malloc(needed);
chaz_bool_t success = false;
/* Verify compilation. */
sprintf(code_buf, lseek_code, combo->includes, combo->lseek_command);
output = CC_capture_output(code_buf, strlen(code_buf), &output_len);
if (output != NULL) {
success = true;
free(output);
}
if (!Util_remove_and_verify("_charm_lseek")) {
Util_die("Failed to remove '_charm_lseek'");
}
free(code_buf);
return success;
}
/* Code for checking 64-bit pread. The pread call will fail, but that's fine
* as long as it compiles. */
static char pread64_code[] =
QUOTE( %s )
QUOTE( #include "_charm.h" )
QUOTE( int main() { )
QUOTE( int fd = 20; )
QUOTE( char buf[1]; )
QUOTE( Charm_Setup; )
QUOTE( printf("1"); )
QUOTE( %s(fd, buf, 1, 1); )
QUOTE( return 0; )
QUOTE( } );
static chaz_bool_t
S_probe_pread64(unbuff_combo *combo)
{
char *output = NULL;
size_t output_len;
size_t needed = sizeof(pread64_code) + strlen(combo->includes)
+ strlen(combo->pread64_command) + 20;
char *code_buf = (char*)malloc(needed);
chaz_bool_t success = false;
/* Verify compilation. */
sprintf(code_buf, pread64_code, combo->includes, combo->pread64_command);
output = CC_capture_output(code_buf, strlen(code_buf), &output_len);
if (output != NULL) {
success = true;
free(output);
}
free(code_buf);
return success;
}
static chaz_bool_t
S_check_sparse_files()
{
Stat st_a, st_b;
/* Bail out if we can't stat() a file. */
if (!HeadCheck_check_header("sys/stat.h"))
return false;
/* Write and stat a 1 MB file and a 2 MB file, both of them sparse. */
S_test_sparse_file(1000000, &st_a);
S_test_sparse_file(2000000, &st_b);
if (!(st_a.valid && st_b.valid))
return false;
if (st_a.size != 1000001)
Util_die("Expected size of 1000001 but got %ld", (long)st_a.size);
if (st_b.size != 2000001)
Util_die("Expected size of 2000001 but got %ld", (long)st_b.size);
/* See if two files with very different lengths have the same block size. */
if (st_a.blocks == st_b.blocks)
return true;
else
return false;
}
static void
S_test_sparse_file(long offset, Stat *st)
{
FILE *sparse_fh;
/* Make sure the file's not there, then open. */
Util_remove_and_verify("_charm_sparse");
if ( (sparse_fh = fopen("_charm_sparse", "w+")) == NULL )
Util_die("Couldn't open file '_charm_sparse'");
/* Seek fh to [offset], write a byte, close file. */
if ( (fseek(sparse_fh, offset, SEEK_SET)) == -1)
Util_die("seek failed: %s", strerror(errno));
if ( (fprintf(sparse_fh, "X")) != 1 )
Util_die("fprintf failed");
if (fclose(sparse_fh))
Util_die("Error closing file '_charm_sparse': %s", strerror(errno));
/* Stat the file. */
Stat_stat("_charm_sparse", st);
remove("_charm_sparse");
}
/* Open a file, seek to a loc, print a char, and communicate success. */
static char create_bigfile_code[] =
QUOTE( #include "_charm.h" )
QUOTE( int main() { )
QUOTE( FILE *fh = fopen("_charm_large_file_test", "w+"); )
QUOTE( int check_seek; )
QUOTE( Charm_Setup; )
/* Bail unless seek succeeds. */
QUOTE( check_seek = %s(fh, 5000000000, SEEK_SET); )
QUOTE( if (check_seek == -1) )
QUOTE( exit(1); )
/* Bail unless we write successfully. */
QUOTE( if (fprintf(fh, "X") != 1) )
QUOTE( exit(1); )
QUOTE( if (fclose(fh)) )
QUOTE( exit(1); )
/* Communicate success to Charmonizer. */
QUOTE( printf("1"); )
QUOTE( return 0; )
QUOTE( } );
static chaz_bool_t
S_can_create_big_files()
{
char *output;
size_t output_len;
FILE *truncating_fh;
size_t needed = strlen(create_bigfile_code)
+ strlen(fseek_command)
+ 10;
char *code_buf = (char*)malloc(needed);
/* Concat the source strings, compile the file, capture output. */
sprintf(code_buf, create_bigfile_code, fseek_command);
output = CC_capture_output(code_buf, strlen(code_buf), &output_len);
/* Truncate, just in case the call to remove fails. */
truncating_fh = fopen("_charm_large_file_test", "w");
if (truncating_fh != NULL)
fclose(truncating_fh);
Util_remove_and_verify("_charm_large_file_test");
/* Return true if the test app made it to the finish line. */
free(code_buf);
return output == NULL ? false : true;
}
/* Copyright 2006-2011 Marvin Humphrey
*
* This program is free software; you can redistribute it and/or modify
* under the same terms as Perl itself.
*/