static int do_mem_probe(u_long base, u_long num,
int (*is_valid)(u_long), int (*do_cksum)(u_long))
{
u_long i, j, bad, fail, step;
printk(KERN_INFO "cs: memory probe 0x%06lx-0x%06lx:",
base, base+num-1);
bad = fail = 0;
step = (num < 0x20000) ? 0x2000 : ((num>>4) & ~0x1fff);
for (i = j = base; i < base+num; i = j + step) {
if (!fail) {
for (j = i; j < base+num; j += step)
if ((check_mem_region(j, step) == 0) && is_valid(j))
break;
fail = ((i == base) && (j == base+num));
}
if (fail) {
for (j = i; j < base+num; j += 2*step)
if ((check_mem_region(j, 2*step) == 0) &&
do_cksum(j) && do_cksum(j+step))
break;
}
if (i != j) {
if (!bad) printk(" excluding");
printk(" %#05lx-%#05lx", i, j-1);
sub_interval(&mem_db, i, j-i);
bad += j-i;
}
}
printk(bad ? "\n" : " clean.\n");
return (num - bad);
}
u_int in_cksum_hdr(const struct ip *ip)
{
u_int64_t sum = do_cksum(ip, sizeof(struct ip));
union q_util q_util;
union l_util l_util;
REDUCE16;
return (~sum & 0xffff);
}
static
uint64_t _do_cksum(void *addr, int len)
{
uint64_t sum;
union q_util q_util;
sum = do_cksum(addr, len);
REDUCE32;
return (sum);
}
int main (int argc, char *argv[])
{
static char cvs_info[] = "BMkGRP $Date: $ $Revision: $ $RCSfile: all2all_main.c,v $ $Name: $";
int itr;
int idx;
brand_t br;
timer t, t0, t1;
double nsec;
double total_time = 0.0;
int status = 0;
int64 i, seed, arg, msize, tsize, len, oldsize=0, rep, cksum;
uint64 *tab=NULL;
start_pes(0);
SELF=_my_pe();
SIZE=_n_pes();
if (argc < 5) {
if (SELF == 0)
fprintf (stderr, "Usage:\t%s seed msg_size(B) table_size(MB) rep_cnt "
"[ms2 ts2 rc2 ..]\n", argv[0]);
status = 1;
goto DONE;
}
seed = atol (argv[1]);
if (SELF == 0)
printf ("base seed is %ld\n", seed);
seed += SELF << 32;
brand_init (&br, seed); // seed uniquely per PE
arg = 2;
while (arg < argc) {
msize = atol (argv[arg++]); if (arg >= argc) break;
/* Table size * 1 million. */
tsize = atol (argv[arg++]) * (1L << 20); if (arg >= argc) break;
//rep = atol (argv[arg++]);
rep = 1;
arg++;
if (SELF == 0) printf ("tsize = %ldMB msize = %dB\n",
tsize/(1L<<20), msize);
if (msize < sizeof(long)) {
if (SELF == 0) printf ("msize too short!\n");
//status = 1;
goto DONE;
}
//itr=0;
idx = 0;
switch(SIZE){
case 2:
idx = 0;
break;
case 4:
idx = 1;
break;
case 8:
idx = 2;
break;
default:
fprintf(stderr,"warning, check sum for (%d) pes not supported.\n",
SIZE);
}
while (rep-- > 0) {
/* START TIMING */
//timer_clear (&t0);
//timer_clear (&t1);
//timer_start (&t0);
if ((tab == NULL) || (tsize > oldsize)) {
if (tab != NULL) {
dram_shfree (tab);
oldsize = 0;
}
if (SELF == 0) printf ("trying dram_shmalloc of %ld bytes\n", tsize);
tab = (uint64 *) dram_shmalloc (tsize);
if (tab == NULL) {
if (SELF == 0) printf ("dram_shmalloc failed!\n");
status = 1;
goto DONE;
}
oldsize = tsize;
}
// length in words
len = tsize / sizeof(uint64);
// important to init table
// to ensure cksum consistency on different platforms
memset(tab,0,tsize);
for (i = 0; i < len; i+=64){
tab[i] = brand(&br);
}
// we'll have destination/source arrays each of half size
len /= 2;
//timer_stop (&t0);
// source checksum
cksum = do_cksum (&tab[len], len);
if (SELF == 0) printf ("cksum is %016lx\n", cksum);
if (SELF == 0){
//if(cksum!=ckv[itr++]){
/* Set up for one iteration only. */
if(cksum!=ckv[idx]){
printf ("cksum %016lx != ckv[%d] %016x\n",cksum,idx,ckv[idx]);
gexit(1);
}
}
//timer_start (&t1);
len = do_all2all (&tab[0], &tab[len], len, msize/sizeof(uint64));
shmem_barrier_all();
//timer_stop (&t1);
/* END TIMING */
#if 0
// dest checksum
i = do_cksum (&tab[0], len);
if (i != cksum) {
printf ("PE %4ld ERROR: %016lx != %016lx\n", SIZE, i, cksum);
status = 1;
goto DONE;
}
#ifndef CHECKOFF
if (i != known_v[gv]) {
printf ("CHECKSUM PE %4ld ERROR: %016lx != %016lx\n", SIZE, i, known_v[gv]);
status = 1;
goto DONE;
}
gv++;
#endif
//t.accum_wall = t0.accum_wall + t1.accum_wall;
//t.accum_cpus = t0.accum_cpus + t1.accum_cpus;
/*if (SELF == 0) {
#ifdef PTIMES
printf ("%8.3f %8.3f\n", t0.accum_wall , t1.accum_wall);
printf ("%8.3f %8.3f\n", t0.accum_cpus , t1.accum_cpus);
#endif
printf ("wall reports %8.3f secs cpus report %8.3f secs\n",
t.accum_wall, t.accum_cpus);
nsec = MAX(t.accum_wall, t.accum_cpus);
total_time += nsec;
if (nsec > 0)
printf ("%8.3f MB/sec with %ld bytes transfers\n",
len*sizeof(uint64)/(double)(1L<<20)/nsec, msize);
}*/
#endif
}
//if (SELF == 0)
//printf ("\n");
}
//if (SELF == 0)
//{
//printf ("total time = %14.9f\n", total_time);
//}
DONE:
shmem_barrier_all();
return status;
}
int
f_stat( SNET *sn, int ac, char *av[] )
{
char path[ MAXPATHLEN ];
char cksum_b64[ SZ_BASE64_E( EVP_MAX_MD_SIZE ) ];
struct stat st;
int key;
char *enc_file, *d_tran, *d_path;
switch ( key = keyword( ac, av )) {
case K_COMMAND:
if ( ac == 2 ) {
if ( snprintf( path, MAXPATHLEN, "command/%s", command_file )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: command/%s: path too long",
command_file );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
} else {
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_path )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s",
d_path );
snet_writef( sn, "%d No access for %s\r\n", 540, d_path );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "command/%s", d_path )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: command path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
}
break;
case K_TRANSCRIPT:
if (( d_tran = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_tran )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s", d_tran );
snet_writef( sn, "%d No access for %s\r\n", 540, d_tran );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "transcript/%s", d_tran )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: transcript path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
case K_SPECIAL:
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "%s/%s", special_dir, d_path)
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: special path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
default:
snet_writef( sn, "%d STAT Syntax error\r\n", 530 );
return( 1 );
}
syslog( LOG_DEBUG, "f_stat: returning infomation for %s", path );
if ( stat( path, &st ) < 0 ) {
syslog( LOG_ERR, "f_stat: stat: %m" );
snet_writef( sn, "%d Access Error: %s\r\n", 531, path );
return( 1 );
}
/* XXX cksums here, totally the wrong place to do this! */
OpenSSL_add_all_digests();
md = EVP_get_digestbyname( "sha1" );
if ( !md ) {
/* XXX */
fprintf( stderr, "%s: unsupported checksum\n", "sha1" );
exit( 1 );
}
if ( do_cksum( path, cksum_b64 ) < 0 ) {
syslog( LOG_ERR, "do_cksum: %s: %m", path );
snet_writef( sn, "%d Checksum Error: %s: %m\r\n", 500, path );
return( 1 );
}
snet_writef( sn, "%d Returning STAT information\r\n", 230 );
switch ( key ) {
case K_COMMAND:
if ( ac == 2 ) {
snet_writef( sn, RADMIND_STAT_FMT,
"f", "command", DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
} else {
snet_writef( sn, RADMIND_STAT_FMT,
"f", av[ 2 ], DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
}
return( 0 );
case K_TRANSCRIPT:
snet_writef( sn, RADMIND_STAT_FMT,
"f", av[ 2 ],
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
return( 0 );
case K_SPECIAL:
/*
* store value of av[ 2 ], because argcargv will be called
* from special_t(), and that will blow away the current values
* for av[ 2 ].
*/
if (( enc_file = strdup( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: strdup: %s %m", av[ 2 ] );
return( -1 );
}
if (( av = special_t( path, enc_file )) == NULL ) {
/* no special transcript match found, return defaults. */
snet_writef( sn, RADMIND_STAT_FMT,
"f", enc_file,
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
free( enc_file );
return( 0 );
}
snet_writef( sn, RADMIND_STAT_FMT,
av[ 0 ], enc_file,
av[ 2 ], av[ 3 ], av[ 4 ],
st.st_mtime, st.st_size, cksum_b64 );
free( enc_file );
return( 0 );
default:
return( 1 );
}
}
int
f_stat( SNET *sn, int ac, char *av[] )
{
char path[ MAXPATHLEN ];
char cksum_b64[ SZ_BASE64_E( EVP_MAX_MD_SIZE ) ];
struct stat st;
int key;
char *enc_file, *d_tran, *d_path;
switch ( key = keyword( ac, av )) {
case K_COMMAND:
if ( ac == 2 ) {
if ( snprintf( path, MAXPATHLEN, "command/%s", command_file )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: command/%s: path too long",
command_file );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
} else {
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_path )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s",
d_path );
snet_writef( sn, "%d No access for %s\r\n", 540, d_path );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "command/%s", d_path )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: command path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
}
break;
case K_TRANSCRIPT:
if (( d_tran = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
/* Check for access */
if ( !list_check( access_list, d_tran )) {
syslog( LOG_WARNING | LOG_AUTH, "attempt to access: %s", d_tran );
snet_writef( sn, "%d No access for %s\r\n", 540, d_tran );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "transcript/%s", d_tran )
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: transcript path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
case K_SPECIAL:
if (( d_path = decode( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: decode: buffer too small" );
snet_writef( sn, "%d Line too long\r\n", 540 );
return( 1 );
}
if ( snprintf( path, MAXPATHLEN, "%s/%s", special_dir, d_path)
>= MAXPATHLEN ) {
syslog( LOG_ERR, "f_stat: special path too long" );
snet_writef( sn, "%d Path too long\r\n", 540 );
return( 1 );
}
break;
default:
snet_writef( sn, "%d STAT Syntax error\r\n", 530 );
return( 1 );
}
syslog( LOG_DEBUG, "f_stat: returning infomation for %s", path );
if ( stat( path, &st ) < 0 ) {
syslog( LOG_ERR, "f_stat: stat: %m" );
snet_writef( sn, "%d Access Error: %s\r\n", 531, path );
return( 1 );
}
/* XXX cksums here, totally the wrong place to do this! */
OpenSSL_add_all_digests();
md = EVP_get_digestbyname( "sha1" );
if ( !md ) {
/* XXX */
fprintf( stderr, "%s: unsupported checksum\n", "sha1" );
exit( 1 );
}
if ( do_cksum( path, cksum_b64 ) < 0 ) {
syslog( LOG_ERR, "do_cksum: %s: %m", path );
snet_writef( sn, "%d Checksum Error: %s: %m\r\n", 500, path );
return( 1 );
}
snet_writef( sn, "%d Returning STAT information\r\n", 230 );
switch ( key ) {
case K_COMMAND:
if ( ac == 2 ) {
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", "command", DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
} else {
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", av[ 2 ], DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
}
return( 0 );
case K_TRANSCRIPT:
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", av[ 2 ],
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
return( 0 );
case K_SPECIAL:
/* status on a special file comes from 1 of three cases:
* 1. A transcript in the special file directory
* 2. A transcript in the Transcript dir with .T appended
* 3. No transcript is found, and constants are returned
*/
/* look for transcript containing the information */
if ( ( strlen( path ) + 2 ) > MAXPATHLEN ) {
syslog( LOG_WARNING,
"f_stat: transcript path longer than MAXPATHLEN" );
/* return constants */
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", av[ 2 ],
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
return( 0 );
}
/* if allowable, check for transcript in the special file directory */
strcat( path, ".T" );
/* store value of av[ 2 ], because argcargv will be called
* from special_t(), and that will blow away the current values
* for av[ 2 ]
*
* Could just use new argvargc API... XXX Notice how we never free
* env_file...
*/
if (( enc_file = strdup( av[ 2 ] )) == NULL ) {
syslog( LOG_ERR, "f_stat: strdup: %s %m", av[ 2 ] );
return( -1 );
}
if (( av = special_t( path, enc_file )) == NULL ) {
if (( av = special_t( "transcript/special.T", enc_file ))
== NULL ) {
snet_writef( sn, "%s %s %o %d %d %d %" PRIofft "d %s\r\n",
"f", enc_file,
DEFAULT_MODE, DEFAULT_UID, DEFAULT_GID,
st.st_mtime, st.st_size, cksum_b64 );
free( enc_file );
return( 0 );
}
}
snet_writef( sn, "%s %s %s %s %s %d %" PRIofft "d %s\r\n",
av[ 0 ], enc_file,
av[ 2 ], av[ 3 ], av[ 4 ],
st.st_mtime, st.st_size, cksum_b64 );
free( enc_file );
return( 0 );
default:
return( 1 );
}
}
