void
x86_process_elf_notes(void *note_ptr, unsigned long size_note)
{
if (machine_type("X86_64"))
process_elf64_notes(note_ptr, size_note);
else if (machine_type("X86"))
process_elf32_notes(note_ptr, size_note);
}
/* SETUP ROUTINES */
static int initial_set(){
int prompt,status;
#ifdef FIX_NODE_GEOM
int i;
#endif
/* On node zero, read lattice size and send to others */
if(mynode()==0){
/* print banner */
printf("SU3 clover, staggered and naive valence fermions\n");
printf("MIMD version %s\n",MILC_CODE_VERSION);
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
gethostname(hostname, 128);
printf("Host(0) = %s\n",hostname);
printf("Username = %s\n", getenv("USER"));
time_stamp("start");
status = get_prompt(stdin, &prompt );
IF_OK status += get_i(stdin,prompt,"nx", ¶m.nx );
IF_OK status += get_i(stdin,prompt,"ny", ¶m.ny );
IF_OK status += get_i(stdin,prompt,"nz", ¶m.nz );
IF_OK status += get_i(stdin,prompt,"nt", ¶m.nt );
#ifdef FIX_NODE_GEOM
IF_OK status += get_vi(stdin, prompt, "node_geometry",
param.node_geometry, 4);
#ifdef FIX_IONODE_GEOM
IF_OK status += get_vi(stdin, prompt, "ionode_geometry",
param.ionode_geometry, 4);
#endif
#endif
IF_OK status += get_s(stdin, prompt,"job_id",param.job_id);
if(status>0) param.stopflag=1; else param.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)¶m,sizeof(param));
if( param.stopflag != 0 )
normal_exit(0);
nx=param.nx;
ny=param.ny;
nz=param.nz;
nt=param.nt;
iseed=param.iseed;
#ifdef FIX_NODE_GEOM
for(i = 0; i < 4; i++)
node_geometry[i] = param.node_geometry[i];
#ifdef FIX_IONODE_GEOM
for(i = 0; i < 4; i++)
ionode_geometry[i] = param.ionode_geometry[i];
#endif
#endif
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
return(prompt);
}
/* SETUP ROUTINES */
int initial_set(){
int prompt,status;
/* On node zero, read lattice size and send to others */
if(mynode()==0){
/* print banner */
printf("SU3 Wilson valence fermion Schroedinger functional\n");
printf("MIMD version 4\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf,sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
nx=par_buf.nx;
ny=par_buf.ny;
nz=par_buf.nz;
nt=par_buf.nt;
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
return(prompt);
}
int main( int argc, char *argv[] )
{
char *opt;
int print;
print = 0;
if( argc > 1 ) {
opt = argv[1];
if( *opt == '/' || *opt == '-' ) {
if( opt[1] == 'v' || opt[1] == 'V' ) {
print = 1;
}
}
if( print == 0 ) {
Usage();
exit(0);
}
}
TechOutFile = fopen( "techinfo.out", "w" );
do_company_header();
get_compiler_patch();
get_wsql_patch();
get_mem_info();
get_config_files();
machine_type( print );
#ifndef __OS2__
check_dos_comm();
#endif
fclose( TechOutFile );
return( 0 );
}
/* SETUP ROUTINES */
int initial_set() {
int prompt,status;
/* On node zero, read lattice size, seed, nflavors and send to others */
if(mynode()==0) {
/* print banner */
printf("SU3 with Wilson fermions\n");
printf("Microcanonical simulation with refreshing\n");
printf("MIMD version 6\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
#ifdef HMC_ALGORITHM
printf("Hybrid Monte Carlo algorithm\n");
#endif
#ifdef PHI_ALGORITHM
printf("PHI algorithm\n");
#else
printf("R algorithm\n");
#endif
#ifdef SPECTRUM
printf("With spectrum measurements\n");
#endif
time_stamp("start");
status = get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt, "nflavors", &par_buf.nflavors );
#ifdef PHI_ALGORITHM
if( par_buf.nflavors != 2) {
printf("Dummy! Use phi algorithm only for two flavors\n");
terminate(-1);
}
#endif
IF_OK status += get_i(stdin, prompt, "nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt, "ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt, "nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt, "nt", &par_buf.nt );
IF_OK status += get_i(stdin, prompt, "iseed", &par_buf.iseed );
if(status>0) par_buf.stopflag=1;
else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf,sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
nx=par_buf.nx;
ny=par_buf.ny;
nz=par_buf.nz;
nt=par_buf.nt;
iseed=par_buf.iseed;
nflavors=par_buf.nflavors;
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
total_iters=0;
return(prompt);
}
/* SETUP ROUTINES */
int initial_set(){
int prompt,status;
/* On node zero, read lattice size, seed, and send to others */
if(mynode()==0){
/* print banner */
printf("SU3 with improved KS action\n");
printf("Eigenvalues and eigenvectors\n");
printf("MIMD version 6\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
gethostname(hostname, 128);
printf("Host(0) = %s\n",hostname);
printf("Username = %s\n", getenv("USER"));
time_stamp("start");
get_utc_datetime(utc_date_time);
/* Print list of options selected */
node0_printf("Options selected...\n");
show_generic_opts();
show_generic_ks_opts();
#if FERM_ACTION == HISQ
show_su3_mat_opts();
show_hisq_links_opts();
#elif FERM_ACTION == HYPISQ
show_su3_mat_opts();
show_hypisq_links_opts();
#endif
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
IF_OK status += get_i(stdin, prompt,"iseed", &par_buf.iseed );
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf,sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
nx=par_buf.nx;
ny=par_buf.ny;
nz=par_buf.nz;
nt=par_buf.nt;
iseed=par_buf.iseed;
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
total_iters=0;
return(prompt);
}
static void
dump_nt_prstatus_offset(FILE *fp)
{
struct kdump_sub_header *sub_header_kdump = dd->sub_header_kdump;
size_t size;
off_t offset;
Elf32_Nhdr *note32 = NULL;
Elf64_Nhdr *note64 = NULL;
size_t tot, len = 0;
if (KDUMP_CMPRS_VALID() && !(dd->flags & NO_ELF_NOTES) &&
(dd->header->header_version >= 4) &&
(sub_header_kdump->offset_note) &&
(sub_header_kdump->size_note) && (machdep->process_elf_notes)) {
size = sub_header_kdump->size_note;
offset = sub_header_kdump->offset_note;
fprintf(fp, " NT_PRSTATUS_offset: ");
for (tot = 0; tot < size; tot += len) {
if (machine_type("X86_64") || machine_type("S390X")) {
note64 = (void *)dd->notes_buf + tot;
len = sizeof(Elf64_Nhdr);
len = roundup(len + note64->n_namesz, 4);
len = roundup(len + note64->n_descsz, 4);
if (note64->n_type == NT_PRSTATUS)
fprintf(fp, "%s%lx\n",
(tot == 0) ? "" : " ",
(ulong)(offset + tot));
} else if (machine_type("X86") || machine_type("PPC")) {
note32 = (void *)dd->notes_buf + tot;
len = sizeof(Elf32_Nhdr);
len = roundup(len + note32->n_namesz, 4);
len = roundup(len + note32->n_descsz, 4);
if (note32->n_type == NT_PRSTATUS)
fprintf(fp, "%s%lx\n",
(tot == 0) ? "" : " ",
(ulong)(offset + tot));
}
}
}
}
/* SETUP ROUTINES */
int initial_set(){
int prompt,status;
/* On node zero, read lattice size, seed, nflavors and send to others */
if(mynode()==0){
/* print banner */
printf("Schroedinger functional for pure gauge SU3\n");
#ifdef RMD_ALGORITHM
printf("Microcanonical simulation with refreshing\n");
#endif
#ifdef HMC_ALGORITHM
printf("Microcanonical simulation with refreshing\n");
#endif
printf("MIMD version 6\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
#ifdef HMC_ALGORITHM
printf("Hybrid Monte Carlo algorithm\n");
#endif
#ifdef ORA_ALGORITHM
printf("Overrelaxed/quasi-heat bath algorithm\n");
#endif
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
IF_OK status += get_i(stdin, prompt,"iseed", &par_buf.iseed );
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf,sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
nx=par_buf.nx;
ny=par_buf.ny;
nz=par_buf.nz;
nt=par_buf.nt;
iseed=par_buf.iseed;
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
return(prompt);
}
// -----------------------------------------------------------------
// On node zero, read and distribute lattice size and random number seed
int initial_set() {
int prompt, status;
if (mynode() == 0) {
// Print banner
printf("SU3 Kogut--Susskind eigenvalue calculation\n");
printf("Machine = %s, with %d nodes\n", machine_type(), numnodes());
printf("nHYP links, reading alpha_smear parameters from infile\n");
printf(" IR_STAB = %.4g\n", (Real)IR_STAB);
printf(" EPS_SQ = %.4g\n", (Real)EPS_SQ);
#ifdef NHYP_DEBUG
printf("NHYP_DEBUG turned on\n");
#endif
#ifdef NO_UNIT_CHECK
printf("NOT checking unitarity when loading lattice\n");
#endif
time_stamp("start");
status = get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt, "nx", &par_buf.nx);
IF_OK status += get_i(stdin, prompt, "ny", &par_buf.ny);
IF_OK status += get_i(stdin, prompt, "nz", &par_buf.nz);
IF_OK status += get_i(stdin, prompt, "nt", &par_buf.nt);
IF_OK status += get_i(stdin, prompt, "iseed", &par_buf.iseed);
if (status > 0)
par_buf.stopflag = 1;
else
par_buf.stopflag = 0;
}
// Broadcast parameter buffer from node 0 to all other nodes
broadcast_bytes((char *)&par_buf, sizeof(par_buf));
if (par_buf.stopflag != 0)
normal_exit(0);
nx = par_buf.nx;
ny = par_buf.ny;
nz = par_buf.nz;
nt = par_buf.nt;
iseed = par_buf.iseed;
this_node = mynode();
number_of_nodes = numnodes();
volume = nx * ny * nz * nt;
total_iters = 0;
return(prompt);
}
/* SETUP ROUTINES */
int
initial_set()
{
int prompt, status;
if(mynode()==0){
/* print banner */
printf("Wilson/Symanzik Flow application\n");
printf("MIMD version 7\n");
printf("Machine = %s, with %d nodes\n", machine_type(), numnodes());
/* Read prompt type and lattice dimensions */
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
if(status>0)
par_buf.stopflag=1;
else
par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf, sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
/* Update global variables with parameters */
nx=par_buf.nx;
ny=par_buf.ny;
nz=par_buf.nz;
nt=par_buf.nt;
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
return prompt;
}
/* SETUP ROUTINES */
int initial_set(){
int prompt,status;
/* On node zero, read lattice size, seed, nflavors and send to others */
if(mynode()==0){
/* print banner */
printf("SU3 with Clover fermions\n");
printf("Microcanonical simulation with refreshing\n");
printf("MIMD version 7\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
#ifdef HMC_ALGORITHM
printf("Hybrid Monte Carlo algorithm\n");
#endif
#ifdef PHI_ALGORITHM
printf("PHI algorithm\n");
#else
printf("R algorithm\n");
#endif
#ifdef SPECTRUM
printf("With spectrum measurements\n");
#endif
time_stamp("start");
status = get_prompt(stdin, &prompt );
IF_OK status += get_i(stdin, prompt,"nflavors", &par_buf.nflavors );
#ifdef PHI_ALGORITHM
IF_OK if(par_buf.nflavors != 2){
printf("Dummy! Use phi algorithm only for two flavors\n");
terminate(-1);
}
#endif
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
IF_OK status += get_i(stdin, prompt,"iseed", &par_buf.iseed );
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* SETUP ROUTINES */
int initial_set(){
int prompt,status;
/* On node zero, read lattice size, seed, and send to others */
if(mynode()==0){
/* print banner */
printf("U1 with improved KS action\n");
printf("Eigenvalues and eigenvectors\n");
printf("MIMD version 6\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
IF_OK status += get_i(stdin, prompt,"iseed", &par_buf.iseed );
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf,sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
nx=par_buf.nx;
ny=par_buf.ny;
nz=par_buf.nz;
nt=par_buf.nt;
iseed=par_buf.iseed;
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
total_iters=0;
return(prompt);
}
/* SETUP ROUTINES */
int initial_set(){
int prompt,status;
/* On node zero, read lattice size, seed, and send to others */
if(mynode()==0){
/* print banner */
printf("Heavy-light spectroscpy with Kogut-Susskind light fermions\n");
printf("MIMD version 7\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
time_stamp("start");
status = get_prompt(stdin, &prompt );
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
IF_OK status += get_s(stdin, prompt,"job_id",par_buf.job_id);
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf,sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
nx=par_buf.nx;
ny=par_buf.ny;
nz=par_buf.nz;
nt=par_buf.nt;
strcpy(job_id,par_buf.job_id);
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
total_iters=0;
return(prompt);
}
static int
verify_paddr(physaddr_t paddr)
{
int i, ok;
if (!machdep->verify_paddr(paddr))
return FALSE;
if (!nr_segments)
return TRUE;
for (i = ok = 0; i < nr_segments; i++) {
if ((paddr >= ram_segments[i].start) &&
(paddr < ram_segments[i].end)) {
ok++;
break;
}
}
/*
* Pre-2.6.13 x86_64 /proc/iomem was restricted to 4GB,
* so just accept it.
*/
if ((paddr >= 0x100000000ULL) &&
machine_type("X86_64") &&
(THIS_KERNEL_VERSION < LINUX(2,6,13)))
ok++;
if (!ok) {
if (CRASHDEBUG(1))
console("reject: %llx\n", (ulonglong)paddr);
return FALSE;
}
return TRUE;
}
/* SETUP ROUTINES */
int initial_set(void)
{
int prompt,status;
/* On node zero, read lattice size, seed, nflavors and send to others */
if(mynode()==0)
{
/* print banner */
printf("SU3 Smoothing for Instantons\n");
printf("MIMD version 7\n");
printf("Machine = %s, with %d nodes\n", machine_type(), numnodes());
time_stamp("start");
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf, sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
nx=par_buf.nx;
ny=par_buf.ny;
nz=par_buf.nz;
nt=par_buf.nt;
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
return prompt;
}
void
diskdump_display_regs(int cpu, FILE *ofp)
{
Elf32_Nhdr *note32;
Elf64_Nhdr *note64;
char *user_regs;
size_t len;
if (cpu >= NR_CPUS || dd->nt_prstatus_percpu[cpu] == NULL) {
error(INFO, "registers not collected for cpu %d\n", cpu);
return;
}
if (machine_type("X86_64")) {
note64 = dd->nt_prstatus_percpu[cpu];
len = sizeof(Elf64_Nhdr);
len = roundup(len + note64->n_namesz, 4);
len = roundup(len + note64->n_descsz, 4);
user_regs = (char *)note64 + len - SIZE(user_regs_struct) - sizeof(long);
fprintf(ofp,
" RIP: %016llx RSP: %016llx RFLAGS: %08llx\n"
" RAX: %016llx RBX: %016llx RCX: %016llx\n"
" RDX: %016llx RSI: %016llx RDI: %016llx\n"
" RBP: %016llx R8: %016llx R9: %016llx\n"
" R10: %016llx R11: %016llx R12: %016llx\n"
" R13: %016llx R14: %016llx R15: %016llx\n"
" CS: %04x SS: %04x\n",
ULONGLONG(user_regs + OFFSET(user_regs_struct_rip)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_rsp)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_eflags)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_rax)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_rbx)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_rcx)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_rdx)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_rsi)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_rdi)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_rbp)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_r8)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_r9)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_r10)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_r11)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_r12)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_r13)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_r14)),
ULONGLONG(user_regs + OFFSET(user_regs_struct_r15)),
USHORT(user_regs + OFFSET(user_regs_struct_cs)),
USHORT(user_regs + OFFSET(user_regs_struct_ss))
);
}
if (machine_type("X86")) {
note32 = dd->nt_prstatus_percpu[cpu];
len = sizeof(Elf32_Nhdr);
len = roundup(len + note32->n_namesz, 4);
len = roundup(len + note32->n_descsz, 4);
user_regs = (char *)note32 + len - SIZE(user_regs_struct) - sizeof(int);
fprintf(ofp,
" EAX: %08x EBX: %08x ECX: %08x EDX: %08x\n"
" ESP: %08x EIP: %08x ESI: %08x EDI: %08x\n"
" CS: %04x DS: %04x ES: %04x FS: %04x\n"
" GS: %04x SS: %04x\n"
" EBP: %08x EFLAGS: %08x\n",
UINT(user_regs + OFFSET(user_regs_struct_eax)),
UINT(user_regs + OFFSET(user_regs_struct_ebx)),
UINT(user_regs + OFFSET(user_regs_struct_ecx)),
UINT(user_regs + OFFSET(user_regs_struct_edx)),
UINT(user_regs + OFFSET(user_regs_struct_esp)),
UINT(user_regs + OFFSET(user_regs_struct_eip)),
UINT(user_regs + OFFSET(user_regs_struct_esi)),
UINT(user_regs + OFFSET(user_regs_struct_edi)),
USHORT(user_regs + OFFSET(user_regs_struct_cs)),
USHORT(user_regs + OFFSET(user_regs_struct_ds)),
USHORT(user_regs + OFFSET(user_regs_struct_es)),
USHORT(user_regs + OFFSET(user_regs_struct_fs)),
USHORT(user_regs + OFFSET(user_regs_struct_gs)),
USHORT(user_regs + OFFSET(user_regs_struct_ss)),
UINT(user_regs + OFFSET(user_regs_struct_ebp)),
UINT(user_regs + OFFSET(user_regs_struct_eflags))
);
}
}
/* SETUP ROUTINES */
int
initial_set()
{
int prompt,status;
int i;
/* On node zero, read lattice size, seed, nflavors1, nflavors2,
nflavors, and send to others */
if(mynode()==0){
/* print banner */
printf("SU3 gauge utility program\n");
printf("MIMD version 7\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", ¶m.nx );
IF_OK status += get_i(stdin, prompt,"ny", ¶m.ny );
IF_OK status += get_i(stdin, prompt,"nz", ¶m.nz );
IF_OK status += get_i(stdin, prompt,"nt", ¶m.nt );
#ifdef FIX_NODE_GEOM
IF_OK status += get_vi(stdin, prompt, "node_geometry",
param.node_geometry, 4);
#ifdef FIX_IONODE_GEOM
IF_OK status += get_vi(stdin, prompt, "ionode_geometry",
param.ionode_geometry, 4);
#endif
#endif
IF_OK status += get_i(stdin, prompt,"iseed", ¶m.iseed );
/* beta, quark masses */
IF_OK status += get_f(stdin, prompt,"beta", ¶m.beta );
IF_OK status += get_i(stdin, prompt,"n_dyn_masses", ¶m.n_dyn_masses );
IF_OK status += get_vf(stdin, prompt, "dyn_mass", param.dyn_mass, param.n_dyn_masses);
IF_OK status += get_vi(stdin, prompt, "dyn_flavors", param.dyn_flavors, param.n_dyn_masses);
/* Get tadpole factor */
IF_OK status += get_f(stdin, prompt, "u0", ¶m.u0);
/* Get translation vector */
if(status>0) param.stopflag=1; else param.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)¶m,sizeof(param));
if( param.stopflag != 0 )
normal_exit(0);
nx=param.nx;
ny=param.ny;
nz=param.nz;
nt=param.nt;
#ifdef FIX_NODE_GEOM
for(i = 0; i < 4; i++)
node_geometry[i] = param.node_geometry[i];
#ifdef FIX_IONODE_GEOM
for(i = 0; i < 4; i++)
ionode_geometry[i] = param.ionode_geometry[i];
#endif
#endif
iseed=param.iseed;
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
beta = param.beta;
n_dyn_masses = param.n_dyn_masses;
for(i = 0; i < n_dyn_masses; i++){
dyn_mass[i] = param.dyn_mass[i];
dyn_flavors[i] = param.dyn_flavors[i];
}
u0 = param.u0;
return prompt;
}
/* SETUP ROUTINES */
static int
initial_set(){
int prompt,status;
#ifdef FIX_NODE_GEOM
int i;
#endif
/* On node zero, read lattice size and send to others */
if(mynode()==0){
/* print banner */
printf("SU3 staggered fermion measurements\n");
printf("MIMD version %s\n",MILC_CODE_VERSION);
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
gethostname(hostname, 128);
printf("Host(0) = %s\n",hostname);
printf("Username = %s\n", getenv("USER"));
time_stamp("start");
get_utc_datetime(utc_date_time);
/* Print list of options selected */
node0_printf("Options selected...\n");
show_generic_opts();
show_generic_ks_opts();
#if FERM_ACTION == HISQ
show_su3_mat_opts();
show_hisq_links_opts();
#elif FERM_ACTION == HYPISQ
show_su3_mat_opts();
show_hypisq_links_opts();
#endif
status = get_prompt(stdin, &prompt );
IF_OK status += get_i(stdin,prompt,"nx", ¶m.nx );
IF_OK status += get_i(stdin,prompt,"ny", ¶m.ny );
IF_OK status += get_i(stdin,prompt,"nz", ¶m.nz );
IF_OK status += get_i(stdin,prompt,"nt", ¶m.nt );
#ifdef FIX_NODE_GEOM
IF_OK status += get_vi(stdin, prompt, "node_geometry",
param.node_geometry, 4);
#ifdef FIX_IONODE_GEOM
IF_OK status += get_vi(stdin, prompt, "ionode_geometry",
param.ionode_geometry, 4);
#endif
#endif
IF_OK status += get_i(stdin, prompt,"iseed", ¶m.iseed );
IF_OK status += get_s(stdin, prompt,"job_id",param.job_id);
if(status>0) param.stopflag=1; else param.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)¶m,sizeof(param));
if( param.stopflag != 0 )
normal_exit(0);
if(prompt==2)return prompt;
nx=param.nx;
ny=param.ny;
nz=param.nz;
nt=param.nt;
iseed=param.iseed;
#ifdef FIX_NODE_GEOM
for(i = 0; i < 4; i++)
node_geometry[i] = param.node_geometry[i];
#ifdef FIX_IONODE_GEOM
for(i = 0; i < 4; i++)
ionode_geometry[i] = param.ionode_geometry[i];
#endif
#endif
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
return(prompt);
}
/* SETUP ROUTINES */
int
initial_set()
{
int prompt,status;
#ifdef FIX_NODE_GEOM
int i;
#endif
/* On node zero, read lattice size, seed and send to others */
if(mynode()==0){
/* print banner */
printf("SU3 with improved KS action\n");
printf("Inversion checking\n");
printf("MIMD version 7\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
#ifdef FIX_NODE_GEOM
IF_OK status += get_vi(stdin, prompt, "node_geometry",
par_buf.node_geometry, 4);
#ifdef FIX_IONODE_GEOM
IF_OK status += get_vi(stdin, prompt, "ionode_geometry",
par_buf.ionode_geometry, 4);
#endif
#endif
IF_OK status += get_i(stdin, prompt,"iseed", &par_buf.iseed );
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf,sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
if(prompt==2)return prompt;
nx=par_buf.nx;
ny=par_buf.ny;
nz=par_buf.nz;
nt=par_buf.nt;
iseed=par_buf.iseed;
#ifdef FIX_NODE_GEOM
for(i = 0; i < 4; i++)
node_geometry[i] = par_buf.node_geometry[i];
#ifdef FIX_IONODE_GEOM
for(i = 0; i < 4; i++)
ionode_geometry[i] = par_buf.ionode_geometry[i];
#endif
#endif
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
#ifdef HISQ_SVD_COUNTER
hisq_svd_counter = 0;
#endif
#ifdef HISQ_FORCE_FILTER_COUNTER
hisq_force_filter_counter = 0;
#endif
return(prompt);
}
/* SETUP ROUTINES */
int
initial_set()
{
int prompt,status,i,tmporder;
Real current_naik_mass;
/* On node zero, read lattice size, seed, and send to others */
if(mynode()==0){
/* print banner */
printf("SU3 with improved KS action\n");
printf("Microcanonical simulation with refreshing\n");
printf("MIMD version 7 $Name: $\n");
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
printf("Rational function hybrid Monte Carlo algorithm\n");
/* Print list of options selected */
node0_printf("Options selected...\n");
show_generic_opts();
show_generic_ks_opts();
#ifdef INT_ALG
node0_printf("INT_ALG=%s\n",ks_int_alg_opt_chr());
#endif
//#ifdef HISQ_NAIK_ADJUSTABLE
// node0_printf("HISQ_NAIK_ADJUSTABLE (means Naik correction is full epsilon and not just mass)\n");
//#endif
#ifdef HISQ_FORCE_FILTER
node0_printf("HISQ_FORCE_FILTER=%f\n",HISQ_FORCE_FILTER);
#endif
#ifdef HISQ_REUNIT_ALLOW_SVD
node0_printf("HISQ_REUNIT_ALLOW_SVD\n");
#endif
#ifdef HISQ_REUNIT_SVD_ONLY
node0_printf("HISQ_REUNIT_SVD_ONLY (used together with HISQ_REUNIT_ALLOW_SVD)\n");
#endif
#ifdef MILC_GLOBAL_DEBUG
node0_printf("MILC_GLOBAL_DEBUG ***********************\n");
#endif
#ifdef HISQ_REUNITARIZATION_DEBUG
node0_printf("HISQ_REUNITARIZATION_DEBUG is ON\n");
#endif
#ifdef HISQ_FF_MULTI_WRAPPER
node0_printf("HISQ_FF_MULTI_WRAPPER is ON\n");
#endif
#ifdef HISQ_FF_DEBUG
node0_printf("HISQ_FF_DEBUG is ON\n");
#endif
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
#ifdef FIX_NODE_GEOM
IF_OK status += get_vi(stdin, prompt, "node_geometry",
par_buf.node_geometry, 4);
#ifdef FIX_IONODE_GEOM
IF_OK status += get_vi(stdin, prompt, "ionode_geometry",
par_buf.ionode_geometry, 4);
#endif
#endif
IF_OK status += get_i(stdin, prompt,"iseed", &par_buf.iseed );
/* Number of pseudofermions */
IF_OK status += get_i(stdin, prompt,"n_pseudo", &par_buf.n_pseudo );
if(par_buf.n_pseudo > MAX_N_PSEUDO){
printf("Error: Too many pseudofermion fields. Recompile. Current max is %d\n"
,MAX_N_PSEUDO);
terminate(1);
}
/* get name of file containing rational function parameters */
IF_OK status += get_s(stdin, prompt, "load_rhmc_params",
par_buf.rparamfile);
/* beta, quark masses */
IF_OK status += get_f(stdin, prompt,"beta", &par_buf.beta );
IF_OK status += get_i(stdin, prompt,"n_dyn_masses", &par_buf.n_dyn_masses );
IF_OK status += get_vf(stdin, prompt, "dyn_mass", par_buf.dyn_mass, par_buf.n_dyn_masses);
IF_OK status += get_vi(stdin, prompt, "dyn_flavors", par_buf.dyn_flavors, par_buf.n_dyn_masses);
IF_OK status += get_f(stdin, prompt,"u0", &par_buf.u0 );
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf,sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
nx = par_buf.nx;
ny = par_buf.ny;
nz = par_buf.nz;
nt = par_buf.nt;
#ifdef FIX_NODE_GEOM
for(i = 0; i < 4; i++)
node_geometry[i] = par_buf.node_geometry[i];
#ifdef FIX_IONODE_GEOM
for(i = 0; i < 4; i++)
ionode_geometry[i] = par_buf.ionode_geometry[i];
#endif
#endif
iseed = par_buf.iseed;
n_pseudo = par_buf.n_pseudo;
strcpy(rparamfile,par_buf.rparamfile);
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
total_iters=0;
/* Load rational function parameters */
rparam = load_rhmc_params(rparamfile, n_pseudo);
if(rparam == NULL)terminate(1);
/* Determine the maximum rational fcn order */
max_rat_order = 0;
for(i = 0; i < n_pseudo; i++){
if(rparam[i].MD.order > max_rat_order)max_rat_order = rparam[i].MD.order;
if(rparam[i].GR.order > max_rat_order)max_rat_order = rparam[i].GR.order;
if(rparam[i].FA.order > max_rat_order)max_rat_order = rparam[i].FA.order;
}
node0_printf("Maximum rational func order is %d\n",max_rat_order);
/* Determine the number of different Naik masses */
current_naik_mass = rparam[0].naik_term_epsilon;
tmporder = 0;
n_naiks = 0;
n_order_naik_total = 0;
for( i=0; i<n_pseudo; i++ ) {
if( rparam[i].naik_term_epsilon != current_naik_mass ) {
if( tmporder > 0 ) {
n_orders_naik[n_naiks] = tmporder;
masses_naik[n_naiks] = current_naik_mass;
current_naik_mass = rparam[i].naik_term_epsilon;
n_naiks++;
n_order_naik_total += tmporder;
tmporder = 0;
}
}
tmporder += rparam[i].MD.order;
n_pseudo_naik[n_naiks]++;
}
if( tmporder > 0 ) {
n_orders_naik[n_naiks] = tmporder;
masses_naik[n_naiks] = current_naik_mass;
n_order_naik_total += tmporder;
n_naiks++;
}
// calculate epsilon corrections for different Naik terms
if( 0!=masses_naik[0] ) {
node0_printf("IN HISQ ACTION FIRST SET OF PSEUDO FERMION FIELDS SHOULD HAVE EPSILON CORRECTION TO NAIK TERM ZERO.\n");
terminate(1);
}
eps_naik[0] = 0.0; // first set of X links always has 0 correction
for( i=1; i<n_naiks; i++ ) {
#ifdef HISQ
//#ifdef HISQ_NAIK_ADJUSTABLE
// value read from rational function file is considered full epsilon correction
eps_naik[i] = masses_naik[i];
//#else
// value read from rational function file is considered quark mass
// and epsilon correction is calculated with the second order perturbation theory,
// HISQ_NAIK_2ND_ORDER is set in the hisq_action.h
// eps_naik[i] = HISQ_NAIK_2ND_ORDER*masses_naik[i]*masses_naik[i];
//#endif
#else /* HISQ */
// IT IS ASSUMED THAT ACTIONS OTHER THAN HISQ DO NOT HAVE
// ANY EPSILON CORRECTION TERMS
eps_naik[i] = 0;
#endif /* HISQ */
}
node0_printf("Naik term correction structure of multi_x:\n");
node0_printf("n_naiks %d\n",n_naiks);
for( i=0; i<n_naiks; i++ ) {
node0_printf("n_pseudo_naik[%d]=%d\n",i,n_pseudo_naik[i]);
node0_printf("n_orders_naik[%d]=%d\n",i,n_orders_naik[i]);
node0_printf("masses_naik[%d]=%f\n",i,masses_naik[i]);
node0_printf("eps_naik[%d]=%f\n",i,eps_naik[i]);
}
node0_printf("n_order_naik_total %d\n",n_order_naik_total);
#ifdef HISQ
if( n_naiks+1 > MAX_NAIK ) {
node0_printf("MAX_NAIK=%d < n_naiks+1=%d\n", MAX_NAIK, n_naiks+1 );
node0_printf("Increase MAX_NAIK\n");
terminate(1);
}
#else /* HISQ */
if( n_naiks>1 ) {
node0_printf("FOR ACTIONS OTHER THAN HISQ EPSILON CORRECTION IS NOT USED.\n");
node0_printf("ONLY ONE SET OF X LINKS IS USED.\n");
node0_printf("SET ALL naik_mass TO 0 IN RATIONAL FUNCTION FILE.\n");
terminate(1);
}
#endif /* HISQ */
beta = par_buf.beta;
n_dyn_masses = par_buf.n_dyn_masses;
for(i = 0; i < n_dyn_masses; i++){
dyn_mass[i] = par_buf.dyn_mass[i];
dyn_flavors[i] = par_buf.dyn_flavors[i];
}
u0 = par_buf.u0;
return(prompt);
}
/* SETUP ROUTINES */
static int
initial_set(void)
{
int prompt,status,i,tmporder;
Real current_naik_epsilon;
/* On node zero, read lattice size, seed, and send to others */
if(mynode()==0){
/* print banner */
printf("SU3 with improved KS action\n");
printf("Microcanonical simulation with refreshing\n");
printf("Rational function hybrid Monte Carlo algorithm\n");
printf("MIMD version %s\n",MILC_CODE_VERSION);
printf("Machine = %s, with %d nodes\n",machine_type(),numnodes());
gethostname(hostname, 128);
printf("Host(0) = %s\n",hostname);
printf("Username = %s\n", getenv("USER"));
time_stamp("start");
/* Print list of options selected */
node0_printf("Options selected...\n");
show_generic_opts();
show_generic_ks_opts();
show_generic_ks_md_opts();
#ifdef INT_ALG
node0_printf("INT_ALG=%s\n",ks_int_alg_opt_chr());
#endif
#if FERM_ACTION == HISQ
show_su3_mat_opts();
show_hisq_links_opts();
show_hisq_force_opts();
#endif
status=get_prompt(stdin, &prompt);
IF_OK status += get_i(stdin, prompt,"nx", &par_buf.nx );
IF_OK status += get_i(stdin, prompt,"ny", &par_buf.ny );
IF_OK status += get_i(stdin, prompt,"nz", &par_buf.nz );
IF_OK status += get_i(stdin, prompt,"nt", &par_buf.nt );
#ifdef FIX_NODE_GEOM
IF_OK status += get_vi(stdin, prompt, "node_geometry",
par_buf.node_geometry, 4);
#ifdef FIX_IONODE_GEOM
IF_OK status += get_vi(stdin, prompt, "ionode_geometry",
par_buf.ionode_geometry, 4);
#endif
#endif
IF_OK status += get_i(stdin, prompt,"iseed", &par_buf.iseed );
/* Number of pseudofermions */
IF_OK status += get_i(stdin, prompt,"n_pseudo", &par_buf.n_pseudo );
if(par_buf.n_pseudo > MAX_N_PSEUDO){
printf("Error: Too many pseudofermion fields. Recompile. Current max is %d\n"
,MAX_N_PSEUDO);
terminate(1);
}
/* get name of file containing rational function parameters */
IF_OK status += get_s(stdin, prompt, "load_rhmc_params",
par_buf.rparamfile);
/* beta, quark masses */
IF_OK status += get_f(stdin, prompt,"beta", &par_buf.beta );
IF_OK status += get_i(stdin, prompt,"n_dyn_masses", &par_buf.n_dyn_masses );
IF_OK status += get_vf(stdin, prompt, "dyn_mass", par_buf.dyn_mass, par_buf.n_dyn_masses);
IF_OK status += get_vi(stdin, prompt, "dyn_flavors", par_buf.dyn_flavors, par_buf.n_dyn_masses);
IF_OK status += get_f(stdin, prompt,"u0", &par_buf.u0 );
if(status>0) par_buf.stopflag=1; else par_buf.stopflag=0;
} /* end if(mynode()==0) */
/* Node 0 broadcasts parameter buffer to all other nodes */
broadcast_bytes((char *)&par_buf,sizeof(par_buf));
if( par_buf.stopflag != 0 )
normal_exit(0);
nx = par_buf.nx;
ny = par_buf.ny;
nz = par_buf.nz;
nt = par_buf.nt;
#ifdef FIX_NODE_GEOM
for(i = 0; i < 4; i++)
node_geometry[i] = par_buf.node_geometry[i];
#ifdef FIX_IONODE_GEOM
for(i = 0; i < 4; i++)
ionode_geometry[i] = par_buf.ionode_geometry[i];
#endif
#endif
iseed = par_buf.iseed;
n_pseudo = par_buf.n_pseudo;
strcpy(rparamfile,par_buf.rparamfile);
this_node = mynode();
number_of_nodes = numnodes();
volume=nx*ny*nz*nt;
total_iters=0;
#ifdef HISQ_SVD_COUNTER
hisq_svd_counter = 0;
#endif
#ifdef HISQ_FORCE_FILTER_COUNTER
hisq_force_filter_counter = 0;
#endif
/* Load rational function parameters */
rparam = load_rhmc_params(rparamfile, n_pseudo);
if(rparam == NULL)terminate(1);
/* Determine the maximum rational fcn order */
max_rat_order = 0;
for(i = 0; i < n_pseudo; i++){
if(rparam[i].MD.order > max_rat_order)max_rat_order = rparam[i].MD.order;
if(rparam[i].GR.order > max_rat_order)max_rat_order = rparam[i].GR.order;
if(rparam[i].FA.order > max_rat_order)max_rat_order = rparam[i].FA.order;
}
node0_printf("Maximum rational func order is %d\n",max_rat_order);
/* Determine the number of different Naik masses
and fill in n_orders_naik and n_pseudo_naik */
current_naik_epsilon = rparam[0].naik_term_epsilon;
tmporder = 0;
n_naiks = 0;
n_order_naik_total = 0;
for( i=0; i<n_pseudo; i++ ) {
if( rparam[i].naik_term_epsilon != current_naik_epsilon ) {
if( tmporder > 0 ) {
n_orders_naik[n_naiks] = tmporder;
eps_naik[n_naiks] = current_naik_epsilon;
current_naik_epsilon = rparam[i].naik_term_epsilon;
n_naiks++;
n_order_naik_total += tmporder;
tmporder = 0;
}
}
tmporder += rparam[i].MD.order;
n_pseudo_naik[n_naiks]++;
}
if( tmporder > 0 ) {
n_orders_naik[n_naiks] = tmporder;
eps_naik[n_naiks] = current_naik_epsilon;
n_order_naik_total += tmporder;
n_naiks++;
}
#if FERM_ACTION == HISQ
// calculate epsilon corrections for different Naik terms
if( 0 != eps_naik[0] ) {
node0_printf("IN HISQ ACTION FIRST SET OF PSEUDO FERMION FIELDS SHOULD HAVE EPSILON CORRECTION TO NAIK TERM ZERO.\n");
terminate(1);
}
#endif
node0_printf("Naik term correction structure of multi_x:\n");
node0_printf("n_naiks %d\n",n_naiks);
for( i=0; i<n_naiks; i++ ) {
node0_printf("n_pseudo_naik[%d]=%d\n", i, n_pseudo_naik[i]);
node0_printf("n_orders_naik[%d]=%d\n", i, n_orders_naik[i]);
#if FERM_ACTION == HISQ
node0_printf("eps_naik[%d]=%f\n", i, eps_naik[i]);
#endif
}
node0_printf("n_order_naik_total %d\n",n_order_naik_total);
#if FERM_ACTION == HISQ
if( n_naiks+1 > MAX_NAIK ) {
node0_printf("MAX_NAIK=%d < n_naiks+1=%d\n", MAX_NAIK, n_naiks+1 );
node0_printf("Increase MAX_NAIK\n");
terminate(1);
}
#else /* HISQ */
if( n_naiks>1 ) {
node0_printf("FOR ACTIONS OTHER THAN HISQ EPSILON CORRECTION IS NOT USED.\n");
node0_printf("ONLY ONE SET OF X LINKS IS USED.\n");
node0_printf("SET ALL naik_mass TO 0 IN RATIONAL FUNCTION FILE.\n");
terminate(1);
}
#endif /* HISQ */
beta = par_buf.beta;
n_dyn_masses = par_buf.n_dyn_masses;
for(i = 0; i < n_dyn_masses; i++){
dyn_mass[i] = par_buf.dyn_mass[i];
dyn_flavors[i] = par_buf.dyn_flavors[i];
}
u0 = par_buf.u0;
return(prompt);
}
char *ramdump_to_elf(void)
{
int i;
char *ptr, *e_file = NULL;
ushort e_machine = 0;
size_t offset, data_offset;
size_t l_offset;
Elf64_Phdr *notes, *load;
Elf64_Ehdr *e_head;
if (machine_type("ARM"))
e_machine = EM_ARM;
else if (machine_type("ARM64"))
e_machine = EM_AARCH64;
else if (machine_type("MIPS"))
e_machine = EM_MIPS;
else
error(FATAL, "ramdump: unsupported machine type: %s\n",
MACHINE_TYPE);
e_head = (Elf64_Ehdr *)malloc(sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr) +
(nodes * sizeof(Elf64_Phdr)) + (CPY_BUF_SZ * 2));
ptr = (char *)e_head;
offset = 0;
alloc_elf_header(e_head, e_machine);
ptr += sizeof(Elf64_Ehdr);
offset += sizeof(Elf64_Ehdr);
notes = (Elf64_Phdr *)ptr;
alloc_notes(notes);
offset += sizeof(Elf64_Phdr);
ptr += sizeof(Elf64_Phdr);
load = (Elf64_Phdr *)ptr;
if (alloc_program_headers(load))
goto end;
offset += sizeof(Elf64_Phdr) * nodes;
ptr += sizeof(Elf64_Phdr) * nodes;
/* Empty note */
notes->p_offset = offset;
l_offset = offset;
data_offset = offset;
for (i = 0; i < nodes; i++) {
load[i].p_offset = l_offset;
l_offset += load[i].p_filesz;
}
e_file = write_elf(load, e_head, data_offset);
end:
free(e_head);
return e_file;
}
/*
* Just pass in an unused filename.
*/
void
cmd_snap(void)
{
int c, fd, n;
physaddr_t paddr;
size_t offset;
char *buf;
char *filename;
struct node_table *nt;
int type;
char *elf_header;
Elf64_Phdr *load;
int load_index;
if (!supported)
error(FATAL, "command not supported on the %s architecture\n",
pc->machine_type);
filename = NULL;
buf = GETBUF(PAGESIZE());
type = KDUMP_ELF64;
while ((c = getopt(argcnt, args, "n")) != EOF) {
switch(c)
{
case 'n':
if (machine_type("X86_64"))
option_not_supported('n');
else
type = NETDUMP_ELF64;
break;
default:
argerrs++;
break;
}
}
if (argerrs || !args[optind])
cmd_usage(pc->curcmd, SYNOPSIS);
while (args[optind]) {
if (filename)
cmd_usage(pc->curcmd, SYNOPSIS);
if (file_exists(args[optind], NULL))
error(FATAL, "%s: file already exists\n", args[optind]);
else if ((fd = open(args[optind], O_RDWR|O_CREAT, 0644)) < 0)
error(FATAL, args[optind]);
filename = args[optind];
optind++;
}
if (!filename)
cmd_usage(pc->curcmd, SYNOPSIS);
init_ram_segments();
if (!(elf_header = generate_elf_header(type, fd, filename)))
error(FATAL, "cannot generate ELF header\n");
load = (Elf64_Phdr *)(elf_header + sizeof(Elf64_Ehdr) + sizeof(Elf64_Phdr));
load_index = machine_type("X86_64") || machine_type("IA64") ? 1 : 0;
for (n = 0; n < vt->numnodes; n++) {
nt = &vt->node_table[n];
paddr = nt->start_paddr;
offset = load[load_index + n].p_offset;
for (c = 0; c < nt->size; c++, paddr += PAGESIZE()) {
if (!verify_paddr(paddr))
continue;
if (!readmem(paddr, PHYSADDR, &buf[0], PAGESIZE(),
"memory page", QUIET|RETURN_ON_ERROR))
continue;
lseek(fd, (off_t)(paddr + offset - nt->start_paddr), SEEK_SET);
if (write(fd, &buf[0], PAGESIZE()) != PAGESIZE())
error(FATAL, "write to dumpfile failed\n");
if (!print_progress(filename, BTOP(paddr)))
return;
}
}
fprintf(stderr, "\r%s: [100%%] ", filename);
fprintf(fp, "\n");
sprintf(buf, "/bin/ls -l %s\n", filename);
system(buf);
FREEBUF(elf_header);
FREEBUF(buf);
}
static int
read_dump_header(char *file)
{
struct disk_dump_header *header = NULL;
struct disk_dump_sub_header *sub_header = NULL;
struct kdump_sub_header *sub_header_kdump = NULL;
size_t size;
int bitmap_len;
int block_size = (int)sysconf(_SC_PAGESIZE);
off_t offset;
const off_t failed = (off_t)-1;
ulong pfn;
int i, j, max_sect_len;
int is_split = 0;
if (block_size < 0)
return FALSE;
restart:
if ((header = realloc(header, block_size)) == NULL)
error(FATAL, "diskdump / compressed kdump: cannot malloc block_size buffer\n");
if (FLAT_FORMAT()) {
if (!read_flattened_format(dd->dfd, 0, header, block_size)) {
error(FATAL, "diskdump / compressed kdump: cannot read header\n");
goto err;
}
} else {
if (lseek(dd->dfd, 0, SEEK_SET) == failed) {
if (CRASHDEBUG(1))
error(INFO, "diskdump / compressed kdump: cannot lseek dump header\n");
goto err;
}
if (read(dd->dfd, header, block_size) < block_size) {
if (CRASHDEBUG(1))
error(INFO, "diskdump / compressed kdump: cannot read dump header\n");
goto err;
}
}
/* validate dump header */
if (!memcmp(header->signature, DISK_DUMP_SIGNATURE,
sizeof(header->signature))) {
dd->flags |= DISKDUMP_LOCAL;
} else if (!memcmp(header->signature, KDUMP_SIGNATURE,
sizeof(header->signature))) {
dd->flags |= KDUMP_CMPRS_LOCAL;
if (header->header_version >= 1)
dd->flags |= ERROR_EXCLUDED;
} else {
if (CRASHDEBUG(1))
error(INFO,
"diskdump / compressed kdump: dump does not have panic dump header\n");
goto err;
}
if (CRASHDEBUG(1))
fprintf(fp, "%s: header->utsname.machine: %s\n",
DISKDUMP_VALID() ? "diskdump" : "compressed kdump",
header->utsname.machine);
if (STRNEQ(header->utsname.machine, "i686") &&
machine_type_mismatch(file, "X86", NULL, 0))
goto err;
else if (STRNEQ(header->utsname.machine, "x86_64") &&
machine_type_mismatch(file, "X86_64", NULL, 0))
goto err;
else if (STRNEQ(header->utsname.machine, "ia64") &&
machine_type_mismatch(file, "IA64", NULL, 0))
goto err;
else if (STREQ(header->utsname.machine, "ppc") &&
machine_type_mismatch(file, "PPC", NULL, 0))
goto err;
else if (STREQ(header->utsname.machine, "ppc64") &&
machine_type_mismatch(file, "PPC64", NULL, 0))
goto err;
else if (STRNEQ(header->utsname.machine, "arm") &&
machine_type_mismatch(file, "ARM", NULL, 0))
goto err;
else if (STRNEQ(header->utsname.machine, "s390x") &&
machine_type_mismatch(file, "S390X", NULL, 0))
goto err;
if (header->block_size != block_size) {
block_size = header->block_size;
if (CRASHDEBUG(1))
fprintf(fp,
"retrying with different block/page size: %d\n",
header->block_size);
goto restart;
}
dd->block_size = header->block_size;
dd->block_shift = ffs(header->block_size) - 1;
if ((DISKDUMP_VALID() &&
(sizeof(*header) + sizeof(void *) * header->nr_cpus > block_size)) ||
header->nr_cpus <= 0) {
error(INFO, "%s: invalid nr_cpus value: %d\n",
DISKDUMP_VALID() ? "diskdump" : "compressed kdump",
header->nr_cpus);
if (!machine_type("S390") && !machine_type("S390X")) {
/* s390 can get register information also from memory */
goto err;
}
}
/* read sub header */
offset = (off_t)block_size;
if (DISKDUMP_VALID()) {
if ((sub_header = malloc(block_size)) == NULL)
error(FATAL, "diskdump: cannot malloc sub_header buffer\n");
if (FLAT_FORMAT()) {
if (!read_flattened_format(dd->dfd, offset, sub_header, block_size)) {
error(INFO, "diskdump: cannot read dump sub header\n");
goto err;
}
} else {
if (lseek(dd->dfd, offset, SEEK_SET) == failed) {
error(INFO, "diskdump: cannot lseek dump sub header\n");
goto err;
}
if (read(dd->dfd, sub_header, block_size) < block_size) {
error(INFO, "diskdump: cannot read dump sub header\n");
goto err;
}
}
dd->sub_header = sub_header;
} else if (KDUMP_CMPRS_VALID()) {
if ((sub_header_kdump = malloc(block_size)) == NULL)
error(FATAL, "compressed kdump: cannot malloc sub_header_kdump buffer\n");
if (FLAT_FORMAT()) {
if (!read_flattened_format(dd->dfd, offset, sub_header_kdump, block_size)) {
error(INFO, "compressed kdump: cannot read dump sub header\n");
goto err;
}
} else {
if (lseek(dd->dfd, offset, SEEK_SET) == failed) {
error(INFO, "compressed kdump: cannot lseek dump sub header\n");
goto err;
}
if (read(dd->dfd, sub_header_kdump, block_size) < block_size) {
error(INFO, "compressed kdump: cannot read dump sub header\n");
goto err;
}
}
dd->sub_header_kdump = sub_header_kdump;
}
/* read memory bitmap */
bitmap_len = block_size * header->bitmap_blocks;
dd->bitmap_len = bitmap_len;
offset = (off_t)block_size * (1 + header->sub_hdr_size);
if ((dd->bitmap = malloc(bitmap_len)) == NULL)
error(FATAL, "%s: cannot malloc bitmap buffer\n",
DISKDUMP_VALID() ? "diskdump" : "compressed kdump");
dd->dumpable_bitmap = calloc(bitmap_len, 1);
if (CRASHDEBUG(8))
fprintf(fp, "%s: memory bitmap offset: %llx\n",
DISKDUMP_VALID() ? "diskdump" : "compressed kdump",
(ulonglong)offset);
if (FLAT_FORMAT()) {
if (!read_flattened_format(dd->dfd, offset, dd->bitmap, bitmap_len)) {
error(INFO, "%s: cannot read memory bitmap\n",
DISKDUMP_VALID() ? "diskdump" : "compressed kdump");
goto err;
}
} else {
if (lseek(dd->dfd, offset, SEEK_SET) == failed) {
error(INFO, "%s: cannot lseek memory bitmap\n",
DISKDUMP_VALID() ? "diskdump" : "compressed kdump");
goto err;
}
if (read(dd->dfd, dd->bitmap, bitmap_len) < bitmap_len) {
error(INFO, "%s: cannot read memory bitmap\n",
DISKDUMP_VALID() ? "diskdump" : "compressed kdump");
goto err;
}
}
if (dump_is_partial(header))
memcpy(dd->dumpable_bitmap, dd->bitmap + bitmap_len/2,
bitmap_len/2);
else
memcpy(dd->dumpable_bitmap, dd->bitmap, bitmap_len);
dd->data_offset
= (1 + header->sub_hdr_size + header->bitmap_blocks)
* header->block_size;
dd->header = header;
if (machine_type("ARM"))
dd->machine_type = EM_ARM;
else if (machine_type("X86"))
dd->machine_type = EM_386;
else if (machine_type("X86_64"))
dd->machine_type = EM_X86_64;
else if (machine_type("IA64"))
dd->machine_type = EM_IA_64;
else if (machine_type("PPC"))
dd->machine_type = EM_PPC;
else if (machine_type("PPC64"))
dd->machine_type = EM_PPC64;
else if (machine_type("S390X"))
dd->machine_type = EM_S390;
else {
error(INFO, "%s: unsupported machine type: %s\n",
DISKDUMP_VALID() ? "diskdump" : "compressed kdump",
MACHINE_TYPE);
goto err;
}
/* process elf notes data */
if (KDUMP_CMPRS_VALID() && !(dd->flags & NO_ELF_NOTES) &&
(dd->header->header_version >= 4) &&
(sub_header_kdump->offset_note) &&
(sub_header_kdump->size_note) && (machdep->process_elf_notes)) {
size = sub_header_kdump->size_note;
offset = sub_header_kdump->offset_note;
if ((dd->notes_buf = malloc(size)) == NULL)
error(FATAL, "compressed kdump: cannot malloc notes"
" buffer\n");
if ((dd->nt_prstatus_percpu = malloc(NR_CPUS * sizeof(void*))) == NULL)
error(FATAL, "compressed kdump: cannot malloc pointer"
" to NT_PRSTATUS notes\n");
if (FLAT_FORMAT()) {
if (!read_flattened_format(dd->dfd, offset, dd->notes_buf, size)) {
error(INFO, "compressed kdump: cannot read notes data"
"\n");
goto err;
}
} else {
if (lseek(dd->dfd, offset, SEEK_SET) == failed) {
error(INFO, "compressed kdump: cannot lseek notes data\n");
goto err;
}
if (read(dd->dfd, dd->notes_buf, size) < size) {
error(INFO, "compressed kdump: cannot read notes data"
"\n");
goto err;
}
}
machdep->process_elf_notes(dd->notes_buf, size);
}
/* Check if dump file contains erasesinfo data */
if (KDUMP_CMPRS_VALID() && (dd->header->header_version >= 5) &&
(sub_header_kdump->offset_eraseinfo) &&
(sub_header_kdump->size_eraseinfo))
pc->flags2 |= ERASEINFO_DATA;
/* For split dumpfile */
if (KDUMP_CMPRS_VALID()) {
is_split = ((dd->header->header_version >= 2) &&
(sub_header_kdump->split));
if ((is_split && (num_dumpfiles != 0) && (dd_list == NULL))||
(!is_split && (num_dumpfiles != 0))) {
clean_diskdump_data();
goto err;
}
if (is_split)
add_diskdump_data(file);
num_dumpfiles++;
}
if (!is_split) {
max_sect_len = divideup(header->max_mapnr, BITMAP_SECT_LEN);
pfn = 0;
dd->filename = file;
}
else {
ulong start = sub_header_kdump->start_pfn;
ulong end = sub_header_kdump->end_pfn;
max_sect_len = divideup(end - start + 1, BITMAP_SECT_LEN);
pfn = start;
}
dd->valid_pages = calloc(sizeof(ulong), max_sect_len + 1);
for (i = 1; i < max_sect_len + 1; i++) {
dd->valid_pages[i] = dd->valid_pages[i - 1];
for (j = 0; j < BITMAP_SECT_LEN; j++, pfn++)
if (page_is_dumpable(pfn))
dd->valid_pages[i]++;
}
return TRUE;
err:
free(header);
if (sub_header)
free(sub_header);
if (sub_header_kdump)
free(sub_header_kdump);
if (dd->bitmap)
free(dd->bitmap);
if (dd->dumpable_bitmap)
free(dd->dumpable_bitmap);
if (dd->notes_buf)
free(dd->notes_buf);
if (dd->nt_prstatus_percpu)
free(dd->nt_prstatus_percpu);
dd->flags &= ~(DISKDUMP_LOCAL|KDUMP_CMPRS_LOCAL);
pc->flags2 &= ~ELF_NOTES;
return FALSE;
}
char *
generate_elf_header(int type, int fd, char *filename)
{
int i, n;
char *buffer, *ptr;
Elf64_Ehdr *elf;
Elf64_Phdr *notes;
Elf64_Phdr *load;
size_t offset, len, l_offset;
size_t data_offset;
struct elf_prpsinfo_64 prpsinfo;
union prstatus prstatus;
int prstatus_len;
ushort e_machine;
int num_segments;
struct node_table *nt;
struct SNAP_info {
ulonglong task_struct;
ulonglong arch_data1;
ulonglong arch_data2;
} SNAP_info;
num_segments = vt->numnodes;
if (machine_type("X86_64")) {
e_machine = EM_X86_64;
prstatus_len = sizeof(prstatus.x86_64);
num_segments += 1; /* mapped kernel section for phys_base */
} else if (machine_type("X86")) {
e_machine = EM_386;
prstatus_len = sizeof(prstatus.x86);
} else if (machine_type("IA64")) {
e_machine = EM_IA_64;
prstatus_len = sizeof(prstatus.ia64);
num_segments += 1; /* mapped kernel section for phys_start */
} else if (machine_type("PPC64")) {
e_machine = EM_PPC64;
prstatus_len = sizeof(prstatus.ppc64);
} else if (machine_type("ARM64")) {
e_machine = EM_AARCH64;
prstatus_len = sizeof(prstatus.arm64);
} else
return NULL;
/* should be enought for the notes + roundup + two blocks */
buffer = (char *)GETBUF(sizeof(Elf64_Ehdr) +
num_segments * sizeof(Elf64_Phdr) + PAGESIZE() * 2);
offset = 0;
ptr = buffer;
/* Elf header */
elf = (Elf64_Ehdr *)ptr;
memcpy(elf->e_ident, ELFMAG, SELFMAG);
elf->e_ident[EI_CLASS] = ELFCLASS64;
#if __BYTE_ORDER == __BIG_ENDIAN
elf->e_ident[EI_DATA] = ELFDATA2MSB;
#else
elf->e_ident[EI_DATA] = ELFDATA2LSB;
#endif
elf->e_ident[EI_VERSION] = EV_CURRENT;
elf->e_ident[EI_OSABI] = ELFOSABI_SYSV;
elf->e_ident[EI_ABIVERSION] = 0;
memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
elf->e_type = ET_CORE;
elf->e_machine = e_machine;
elf->e_version = EV_CURRENT;
elf->e_entry = 0;
elf->e_phoff = sizeof(Elf64_Ehdr);
elf->e_shoff = 0;
elf->e_flags = 0;
elf->e_ehsize = sizeof(Elf64_Ehdr);
elf->e_phentsize = sizeof(Elf64_Phdr);
elf->e_phnum = 1 + num_segments;
elf->e_shentsize = 0;
elf->e_shnum = 0;
elf->e_shstrndx = 0;
offset += sizeof(Elf64_Ehdr);
ptr += sizeof(Elf64_Ehdr);
/* PT_NOTE */
notes = (Elf64_Phdr *)ptr;
notes->p_type = PT_NOTE;
notes->p_offset = 0; /* TO BE FILLED IN */
notes->p_vaddr = 0;
notes->p_paddr = 0;
notes->p_filesz = 0; /* TO BE FILLED IN */
notes->p_memsz = 0;
notes->p_flags = 0;
notes->p_align = 0;
offset += sizeof(Elf64_Phdr);
ptr += sizeof(Elf64_Phdr);
/* PT_LOAD */
load = (Elf64_Phdr *)ptr;
for (i = n = 0; i < num_segments; i++) {
load[i].p_type = PT_LOAD;
load[i].p_offset = 0; /* TO BE FILLED IN */
switch (e_machine)
{
case EM_X86_64:
nt = &vt->node_table[n];
if (i == 0) {
#ifdef X86_64
load[i].p_vaddr = __START_KERNEL_map;
load[i].p_paddr = machdep->machspec->phys_base;
#endif
load[i].p_filesz = 0;
load[i].p_memsz = load[i].p_filesz;
} else {
load[i].p_vaddr = PTOV(nt->start_paddr);
load[i].p_paddr = nt->start_paddr;
load[i].p_filesz = nt->size * PAGESIZE();
load[i].p_memsz = load[i].p_filesz;
n++;
}
load[i].p_flags = PF_R | PF_W | PF_X;
load[i].p_align = 0;
break;
case EM_386:
nt = &vt->node_table[n++];
load[i].p_vaddr = 0;
load[i].p_paddr = nt->start_paddr;
load[i].p_filesz = nt->size * PAGESIZE();
load[i].p_memsz = load[i].p_filesz;
load[i].p_flags = PF_R | PF_W | PF_X;
load[i].p_align = (type == NETDUMP_ELF64) ? PAGESIZE() : 0;
break;
case EM_IA_64:
nt = &vt->node_table[n];
if (i == 0) {
#ifdef IA64
load[i].p_vaddr = machdep->machspec->kernel_start;
load[i].p_paddr = machdep->machspec->phys_start;
#endif
load[i].p_filesz = 0;
load[i].p_memsz = load[i].p_filesz;
} else {
load[i].p_vaddr = PTOV(nt->start_paddr);
load[i].p_paddr = nt->start_paddr;
load[i].p_filesz = nt->size * PAGESIZE();
load[i].p_memsz = load[i].p_filesz;
n++;
}
load[i].p_flags = PF_R | PF_W | PF_X;
load[i].p_align = (type == NETDUMP_ELF64) ? PAGESIZE() : 0;
break;
case EM_PPC64:
nt = &vt->node_table[n++];
load[i].p_vaddr = PTOV(nt->start_paddr);
load[i].p_paddr = nt->start_paddr;
load[i].p_filesz = nt->size * PAGESIZE();
load[i].p_memsz = load[i].p_filesz;
load[i].p_flags = PF_R | PF_W | PF_X;
load[i].p_align = (type == NETDUMP_ELF64) ? PAGESIZE() : 0;
break;
case EM_AARCH64:
nt = &vt->node_table[n++];
load[i].p_vaddr = PTOV(nt->start_paddr);
load[i].p_paddr = nt->start_paddr;
load[i].p_filesz = nt->size * PAGESIZE();
load[i].p_memsz = load[i].p_filesz;
load[i].p_flags = PF_R | PF_W | PF_X;
load[i].p_align = (type == NETDUMP_ELF64) ? PAGESIZE() : 0;
break;
}
// l_offset += load[i].p_filesz;
offset += sizeof(Elf64_Phdr);
ptr += sizeof(Elf64_Phdr);
}
notes->p_offset = offset;
/* NT_PRSTATUS note */
memset(&prstatus, 0, sizeof(prstatus));
len = dump_elf_note(ptr, NT_PRSTATUS, "CORE",
(char *)&prstatus, prstatus_len);
offset += len;
ptr += len;
notes->p_filesz += len;
/* NT_PRPSINFO note */
memset(&prpsinfo, 0, sizeof(struct elf_prpsinfo_64));
prpsinfo.pr_state = 0;
prpsinfo.pr_sname = 'R';
prpsinfo.pr_zomb = 0;
strcpy(prpsinfo.pr_fname, "vmlinux");
len = dump_elf_note(ptr, NT_PRPSINFO, "CORE",
(char *)&prpsinfo, sizeof(prpsinfo));
offset += len;
ptr += len;
notes->p_filesz += len;
/* NT_TASKSTRUCT note */
SNAP_info.task_struct = CURRENT_TASK();
#ifdef X86_64
SNAP_info.arch_data1 = kt->relocate;
SNAP_info.arch_data2 = 0;
#elif ARM64
SNAP_info.arch_data1 = machdep->machspec->kimage_voffset;
SNAP_info.arch_data2 = (machdep->machspec->VA_BITS_ACTUAL << 32) |
machdep->machspec->CONFIG_ARM64_VA_BITS;
#else
SNAP_info.arch_data1 = 0;
SNAP_info.arch_data2 = 0;
#endif
len = dump_elf_note (ptr, NT_TASKSTRUCT, "SNAP",
(char *)&SNAP_info, sizeof(struct SNAP_info));
offset += len;
ptr += len;
notes->p_filesz += len;
if (type == NETDUMP_ELF64)
offset = roundup (offset, PAGESIZE());
l_offset = offset;
for (i = 0; i < num_segments; i++) {
load[i].p_offset = l_offset;
l_offset += load[i].p_filesz;
}
data_offset = offset;
while (offset > 0) {
len = write(fd, buffer + (data_offset - offset), offset);
if (len < 0) {
perror(filename);
FREEBUF(buffer);
return NULL;
}
offset -= len;
}
return buffer;
}
