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; }