/* * Actual dumper * * This is a two-pass process; first we find the offsets of the bits, * and then they are actually written out. If we run out of core limit * we just truncate. */ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file) { int has_dumped = 0; mm_segment_t fs; int segs; size_t size = 0; int i; struct vm_area_struct *vma; struct elfhdr elf; off_t offset = 0, dataoff; unsigned long limit = current->rlim[RLIMIT_CORE].rlim_cur; int numnote = 4; struct memelfnote notes[4]; struct elf_prstatus prstatus; /* NT_PRSTATUS */ elf_fpregset_t fpu; /* NT_PRFPREG */ struct elf_prpsinfo psinfo; /* NT_PRPSINFO */ /* first copy the parameters from user space */ memset(&psinfo, 0, sizeof(psinfo)); { unsigned int i, len; len = current->mm->arg_end - current->mm->arg_start; if (len >= ELF_PRARGSZ) len = ELF_PRARGSZ-1; copy_from_user(&psinfo.pr_psargs, (const char *)current->mm->arg_start, len); for(i = 0; i < len; i++) if (psinfo.pr_psargs[i] == 0) psinfo.pr_psargs[i] = ' '; psinfo.pr_psargs[len] = 0; } memset(&prstatus, 0, sizeof(prstatus)); /* * This transfers the registers from regs into the standard * coredump arrangement, whatever that is. */ #ifdef ELF_CORE_COPY_REGS ELF_CORE_COPY_REGS(prstatus.pr_reg, regs) #else if (sizeof(elf_gregset_t) != sizeof(struct pt_regs)) { printk("sizeof(elf_gregset_t) (%ld) != sizeof(struct pt_regs) (%ld)\n", (long)sizeof(elf_gregset_t), (long)sizeof(struct pt_regs)); } else *(struct pt_regs *)&prstatus.pr_reg = *regs; #endif /* now stop all vm operations */ down_write(¤t->mm->mmap_sem); segs = current->mm->map_count; #ifdef DEBUG printk("elf_core_dump: %d segs %lu limit\n", segs, limit); #endif /* Set up header */ memcpy(elf.e_ident, ELFMAG, SELFMAG); elf.e_ident[EI_CLASS] = ELF_CLASS; elf.e_ident[EI_DATA] = ELF_DATA; elf.e_ident[EI_VERSION] = EV_CURRENT; memset(elf.e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD); elf.e_type = ET_CORE; elf.e_machine = ELF_ARCH; elf.e_version = EV_CURRENT; elf.e_entry = 0; elf.e_phoff = sizeof(elf); elf.e_shoff = 0; #ifdef ELF_CORE_EFLAGS elf.e_flags = ELF_CORE_EFLAGS; #else elf.e_flags = 0; #endif elf.e_ehsize = sizeof(elf); elf.e_phentsize = sizeof(struct elf_phdr); elf.e_phnum = segs+1; /* Include notes */ elf.e_shentsize = 0; elf.e_shnum = 0; elf.e_shstrndx = 0; fs = get_fs(); set_fs(KERNEL_DS); has_dumped = 1; current->flags |= PF_DUMPCORE; DUMP_WRITE(&elf, sizeof(elf)); offset += sizeof(elf); /* Elf header */ offset += (segs+1) * sizeof(struct elf_phdr); /* Program headers */ /* * Set up the notes in similar form to SVR4 core dumps made * with info from their /proc. */ notes[0].name = "CORE"; notes[0].type = NT_PRSTATUS; notes[0].datasz = sizeof(prstatus); notes[0].data = &prstatus; prstatus.pr_info.si_signo = prstatus.pr_cursig = signr; prstatus.pr_sigpend = current->pending.signal.sig[0]; prstatus.pr_sighold = current->blocked.sig[0]; psinfo.pr_pid = prstatus.pr_pid = current->pid; psinfo.pr_ppid = prstatus.pr_ppid = current->p_pptr->pid; psinfo.pr_pgrp = prstatus.pr_pgrp = current->pgrp; psinfo.pr_sid = prstatus.pr_sid = current->session; prstatus.pr_utime.tv_sec = CT_TO_SECS(current->times.tms_utime); prstatus.pr_utime.tv_usec = CT_TO_USECS(current->times.tms_utime); prstatus.pr_stime.tv_sec = CT_TO_SECS(current->times.tms_stime); prstatus.pr_stime.tv_usec = CT_TO_USECS(current->times.tms_stime); prstatus.pr_cutime.tv_sec = CT_TO_SECS(current->times.tms_cutime); prstatus.pr_cutime.tv_usec = CT_TO_USECS(current->times.tms_cutime); prstatus.pr_cstime.tv_sec = CT_TO_SECS(current->times.tms_cstime); prstatus.pr_cstime.tv_usec = CT_TO_USECS(current->times.tms_cstime); #ifdef DEBUG dump_regs("Passed in regs", (elf_greg_t *)regs); dump_regs("prstatus regs", (elf_greg_t *)&prstatus.pr_reg); #endif notes[1].name = "CORE"; notes[1].type = NT_PRPSINFO; notes[1].datasz = sizeof(psinfo); notes[1].data = &psinfo; i = current->state ? ffz(~current->state) + 1 : 0; psinfo.pr_state = i; psinfo.pr_sname = (i < 0 || i > 5) ? '.' : "RSDZTD"[i]; psinfo.pr_zomb = psinfo.pr_sname == 'Z'; psinfo.pr_nice = task_nice(current); psinfo.pr_flag = current->flags; psinfo.pr_uid = NEW_TO_OLD_UID(current->uid); psinfo.pr_gid = NEW_TO_OLD_GID(current->gid); strncpy(psinfo.pr_fname, current->comm, sizeof(psinfo.pr_fname)); notes[2].name = "CORE"; notes[2].type = NT_TASKSTRUCT; notes[2].datasz = sizeof(*current); notes[2].data = current; /* Try to dump the FPU. */ prstatus.pr_fpvalid = dump_fpu (regs, &fpu); if (!prstatus.pr_fpvalid) { numnote--; } else { notes[3].name = "CORE"; notes[3].type = NT_PRFPREG; notes[3].datasz = sizeof(fpu); notes[3].data = &fpu; } /* Write notes phdr entry */ { struct elf_phdr phdr; int sz = 0; for(i = 0; i < numnote; i++) sz += notesize(¬es[i]); phdr.p_type = PT_NOTE; phdr.p_offset = offset; phdr.p_vaddr = 0; phdr.p_paddr = 0; phdr.p_filesz = sz; phdr.p_memsz = 0; phdr.p_flags = 0; phdr.p_align = 0; offset += phdr.p_filesz; DUMP_WRITE(&phdr, sizeof(phdr)); } /* Page-align dumped data */ dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE); /* Write program headers for segments dump */ for(vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) { struct elf_phdr phdr; size_t sz; sz = vma->vm_end - vma->vm_start; phdr.p_type = PT_LOAD; phdr.p_offset = offset; phdr.p_vaddr = vma->vm_start; phdr.p_paddr = 0; phdr.p_filesz = maydump(vma) ? sz : 0; phdr.p_memsz = sz; offset += phdr.p_filesz; phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0; if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W; if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X; phdr.p_align = ELF_EXEC_PAGESIZE; DUMP_WRITE(&phdr, sizeof(phdr)); } for(i = 0; i < numnote; i++) if (!writenote(¬es[i], file)) goto end_coredump; DUMP_SEEK(dataoff); for(vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) { unsigned long addr; if (!maydump(vma)) continue; #ifdef DEBUG printk("elf_core_dump: writing %08lx-%08lx\n", vma->vm_start, vma->vm_end); #endif for (addr = vma->vm_start; addr < vma->vm_end; addr += PAGE_SIZE) { struct page* page; struct vm_area_struct *vma; if (get_user_pages(current, current->mm, addr, 1, 0, 1, &page, &vma) <= 0) { DUMP_SEEK (file->f_pos + PAGE_SIZE); } else { if (page == ZERO_PAGE(addr)) { DUMP_SEEK (file->f_pos + PAGE_SIZE); } else { void *kaddr; flush_cache_page(vma, addr); kaddr = kmap(page); DUMP_WRITE(kaddr, PAGE_SIZE); flush_page_to_ram(page); kunmap(page); } put_page(page); } } } if ((off_t) file->f_pos != offset) { /* Sanity check */ printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n", (off_t) file->f_pos, offset); } end_coredump: set_fs(fs); up_write(¤t->mm->mmap_sem); return has_dumped; }
static /* reads score{} section */ void readscore(Inst *insttop) { char s[128]; Inst *p; Rat grpmul, timesig, curtime, lastbar, lastnote, rattmp; Tempo *tempotop, *tempop; Note *notetop, *pn, *qn, *ln; Nextp *nextlist, *nextpp; int accidentals, octaves, vertical, key[PITCHCLASSES], barkey[PITCHCLASSES], transpose, z; double maxtime, fcurtime; #ifdef DEBUG printf("Reading score section\n"); #endif maxtime = 0.0; if (expectchar('{')) scotferror(Str("Syntax error: no {")); tempotop = (Tempo *) malloc(sizeof(Tempo)); tempotop->time.num = 0; tempotop->time.denom = 1; tempotop->val = 60; tempotop->next = NULL; for (;;) { tempop = tempotop; efindword(s); if (s[0] == '}') break; if (s[0] != '$') scotferror(Str("No instrument specified")); p = insttop; while ((p != NULL) && (strcmp(&s[1], p->name))) p = p->next; if (p == NULL) scotferror(Str("Instrument not defined")); notetop = ln = NULL; grpmul.num = 1; grpmul.denom = 1; timesig.num = 0; timesig.denom = 1; curtime.num = 0; curtime.denom = 1; lastbar.num = 0; lastbar.denom = 1; lastnote.num = 0; lastnote.denom = 1; accidentals = octaves = vertical = TRUE; for (z = 0; z < PITCHCLASSES; z++) key[z] = barkey[z] = 0; transpose = 0; nextlist = NULL; readinstsec(p, &nextlist, &grpmul, ×ig, &curtime, &lastbar, &lastnote, ¬etop, &ln, &tempop, &accidentals, &octaves, &vertical, key, barkey, &transpose, "}$"); for (pn = notetop; pn; pn = pn->next) { if (!pn->written) { char *ps, *ps2; for (nextpp = nextlist; nextpp; nextpp = nextpp->next) { ps = findparam(nextpp->dst, &pn->carryp); if (!strcmp(ps, NEXTP)) { ps2 = findparam(nextpp->src, &pn->p); if (!strcmp(ps2, ".")) ps2 = findparam(nextpp->src, &pn->carryp); strcpy(ps, ps2); } } writenote(pn); } if (pn->tie) scoterror(Str("unresolved tie")); if (pn->slur & 1) scoterror(Str("unresolved slur")); ratadd(&rattmp, &pn->start, &pn->dur); if (ratcmp(&rattmp, &curtime) > 0) ratass(&curtime, &rattmp); #ifdef DEBUG if (pn == pn->next) scotferror(Str("Circular note list\n")); #endif } while (nextlist) { nextpp = nextlist; nextlist = nextlist->next; free((char *) nextpp); } pn = notetop; while (pn) { qn = pn; pn = pn->next; freenote(qn); } fcurtime = ratval(&curtime); if (fcurtime > maxtime) maxtime = fcurtime; } tempop = tempotop; putc('t', outfile); for (;;) { tempotop = tempop; tempop = tempop->next; fprintf(outfile, "%g %d", ratval(&tempotop->time), tempotop->val); free((char *) tempotop); if (!tempop) break; putc(' ', outfile); } fprintf(outfile, "\nf0 %g\ns\n", maxtime); }
/* Actual dumper. * * This is a two-pass process; first we find the offsets of the bits, * and then they are actually written out. If we run out of core limit * we just truncate. */ static int irix_core_dump(long signr, struct pt_regs *regs, struct file *file, unsigned long limit) { int has_dumped = 0; mm_segment_t fs; int segs; int i; size_t size; struct vm_area_struct *vma; struct elfhdr elf; off_t offset = 0, dataoff; int numnote = 3; struct memelfnote notes[3]; struct elf_prstatus prstatus; /* NT_PRSTATUS */ elf_fpregset_t fpu; /* NT_PRFPREG */ struct elf_prpsinfo psinfo; /* NT_PRPSINFO */ /* Count what's needed to dump, up to the limit of coredump size. */ segs = 0; size = 0; for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) { if (maydump(vma)) { int sz = vma->vm_end-vma->vm_start; if (size+sz >= limit) break; else size += sz; } segs++; } pr_debug("irix_core_dump: %d segs taking %d bytes\n", segs, size); /* Set up header. */ memcpy(elf.e_ident, ELFMAG, SELFMAG); elf.e_ident[EI_CLASS] = ELFCLASS32; elf.e_ident[EI_DATA] = ELFDATA2LSB; elf.e_ident[EI_VERSION] = EV_CURRENT; elf.e_ident[EI_OSABI] = ELF_OSABI; memset(elf.e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD); elf.e_type = ET_CORE; elf.e_machine = ELF_ARCH; elf.e_version = EV_CURRENT; elf.e_entry = 0; elf.e_phoff = sizeof(elf); elf.e_shoff = 0; elf.e_flags = 0; elf.e_ehsize = sizeof(elf); elf.e_phentsize = sizeof(struct elf_phdr); elf.e_phnum = segs+1; /* Include notes. */ elf.e_shentsize = 0; elf.e_shnum = 0; elf.e_shstrndx = 0; fs = get_fs(); set_fs(KERNEL_DS); has_dumped = 1; current->flags |= PF_DUMPCORE; DUMP_WRITE(&elf, sizeof(elf)); offset += sizeof(elf); /* Elf header. */ offset += (segs+1) * sizeof(struct elf_phdr); /* Program headers. */ /* Set up the notes in similar form to SVR4 core dumps made * with info from their /proc. */ memset(&psinfo, 0, sizeof(psinfo)); memset(&prstatus, 0, sizeof(prstatus)); notes[0].name = "CORE"; notes[0].type = NT_PRSTATUS; notes[0].datasz = sizeof(prstatus); notes[0].data = &prstatus; prstatus.pr_info.si_signo = prstatus.pr_cursig = signr; prstatus.pr_sigpend = current->pending.signal.sig[0]; prstatus.pr_sighold = current->blocked.sig[0]; psinfo.pr_pid = prstatus.pr_pid = task_pid_vnr(current); psinfo.pr_ppid = prstatus.pr_ppid = task_pid_vnr(current->parent); psinfo.pr_pgrp = prstatus.pr_pgrp = task_pgrp_vnr(current); psinfo.pr_sid = prstatus.pr_sid = task_session_vnr(current); if (thread_group_leader(current)) { /* * This is the record for the group leader. Add in the * cumulative times of previous dead threads. This total * won't include the time of each live thread whose state * is included in the core dump. The final total reported * to our parent process when it calls wait4 will include * those sums as well as the little bit more time it takes * this and each other thread to finish dying after the * core dump synchronization phase. */ jiffies_to_timeval(current->utime + current->signal->utime, &prstatus.pr_utime); jiffies_to_timeval(current->stime + current->signal->stime, &prstatus.pr_stime); } else { jiffies_to_timeval(current->utime, &prstatus.pr_utime); jiffies_to_timeval(current->stime, &prstatus.pr_stime); } jiffies_to_timeval(current->signal->cutime, &prstatus.pr_cutime); jiffies_to_timeval(current->signal->cstime, &prstatus.pr_cstime); if (sizeof(elf_gregset_t) != sizeof(struct pt_regs)) { printk("sizeof(elf_gregset_t) (%d) != sizeof(struct pt_regs) " "(%d)\n", sizeof(elf_gregset_t), sizeof(struct pt_regs)); } else { *(struct pt_regs *)&prstatus.pr_reg = *regs; } notes[1].name = "CORE"; notes[1].type = NT_PRPSINFO; notes[1].datasz = sizeof(psinfo); notes[1].data = &psinfo; i = current->state ? ffz(~current->state) + 1 : 0; psinfo.pr_state = i; psinfo.pr_sname = (i < 0 || i > 5) ? '.' : "RSDZTD"[i]; psinfo.pr_zomb = psinfo.pr_sname == 'Z'; psinfo.pr_nice = task_nice(current); psinfo.pr_flag = current->flags; psinfo.pr_uid = current->uid; psinfo.pr_gid = current->gid; { int i, len; set_fs(fs); len = current->mm->arg_end - current->mm->arg_start; len = len >= ELF_PRARGSZ ? ELF_PRARGSZ : len; (void *) copy_from_user(&psinfo.pr_psargs, (const char __user *)current->mm->arg_start, len); for (i = 0; i < len; i++) if (psinfo.pr_psargs[i] == 0) psinfo.pr_psargs[i] = ' '; psinfo.pr_psargs[len] = 0; set_fs(KERNEL_DS); } strlcpy(psinfo.pr_fname, current->comm, sizeof(psinfo.pr_fname)); /* Try to dump the FPU. */ prstatus.pr_fpvalid = dump_fpu(regs, &fpu); if (!prstatus.pr_fpvalid) { numnote--; } else { notes[2].name = "CORE"; notes[2].type = NT_PRFPREG; notes[2].datasz = sizeof(fpu); notes[2].data = &fpu; } /* Write notes phdr entry. */ { struct elf_phdr phdr; int sz = 0; for (i = 0; i < numnote; i++) sz += notesize(¬es[i]); phdr.p_type = PT_NOTE; phdr.p_offset = offset; phdr.p_vaddr = 0; phdr.p_paddr = 0; phdr.p_filesz = sz; phdr.p_memsz = 0; phdr.p_flags = 0; phdr.p_align = 0; offset += phdr.p_filesz; DUMP_WRITE(&phdr, sizeof(phdr)); } /* Page-align dumped data. */ dataoff = offset = roundup(offset, PAGE_SIZE); /* Write program headers for segments dump. */ for (vma = current->mm->mmap, i = 0; i < segs && vma != NULL; vma = vma->vm_next) { struct elf_phdr phdr; size_t sz; i++; sz = vma->vm_end - vma->vm_start; phdr.p_type = PT_LOAD; phdr.p_offset = offset; phdr.p_vaddr = vma->vm_start; phdr.p_paddr = 0; phdr.p_filesz = maydump(vma) ? sz : 0; phdr.p_memsz = sz; offset += phdr.p_filesz; phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0; if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W; if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X; phdr.p_align = PAGE_SIZE; DUMP_WRITE(&phdr, sizeof(phdr)); } for (i = 0; i < numnote; i++) if (!writenote(¬es[i], file)) goto end_coredump; set_fs(fs); DUMP_SEEK(dataoff); for (i = 0, vma = current->mm->mmap; i < segs && vma != NULL; vma = vma->vm_next) { unsigned long addr = vma->vm_start; unsigned long len = vma->vm_end - vma->vm_start; if (!maydump(vma)) continue; i++; pr_debug("elf_core_dump: writing %08lx %lx\n", addr, len); DUMP_WRITE((void __user *)addr, len); } if ((off_t) file->f_pos != offset) { /* Sanity check. */ printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n", (off_t) file->f_pos, offset); } end_coredump: set_fs(fs); return has_dumped; }
static /* reads from one $instrument to the next */ void readinstsec(Inst *inst, Nextp **nextlist, Rat *grpmul, Rat *timesig, Rat *curtime, Rat *lastbar, Rat *lastnote, Note **notetop, Note **ln, Tempo **tempop, int *accidentals, int *octaves, int *vertical, int *key, int *barkey, int *transpose, char *endchar) { static Rat durdiv = { 4L, 1L }; int c, z, lastpitchclass; char s[128], *sp; Rat ratstack, rattmp; Note *pn, *nn, *pn2 = NULL; Strlist *ps; Nextp *nextpp; #ifdef DEBUG printf("Reading instrument section: %s\n", inst->name); #endif pn = (*notetop); for (;;) { findchar(&c); if (strchr(endchar, c)) break; #ifdef DEBUG printf("Processing char: %c\n", c); #endif switch (c) { case 't': if (findint(&c)) { scoterror(Str("Tempo must be specified")); break; } if ((*tempop)->next) { scoterror(Str("Redefinition of tempo")); break; } (*tempop)->next = (Tempo *) malloc(sizeof(Tempo)); *tempop = (*tempop)->next; (*tempop)->next = NULL; ratass(&((*tempop)->time), curtime); (*tempop)->val = c; break; case '!': efindword(s); if ((c = strlen(s)) < 2) scoterror(Str("Must specify 2 or more letters of keyword")); if (!strncmp(s, "accidentals", c)) { if (findonoff(accidentals)) scoterror(Str("Must be \"on\" or \"off\"")); #ifdef DEBUG printf(" accidentals %s\n", accidentals ? "on" : "off"); #endif } else if (!strncmp(s, "octaves", c)) { if (findonoff(octaves)) scoterror(Str("Must be \"on\" or \"off\"")); #ifdef DEBUG printf(" ocatves %s\n", *octaves ? "on" : "off"); #endif } else if (!strncmp(s, "vertical", c)) { if (findonoff(vertical)) scoterror(Str("Must be \"on\" or \"off\"")); #ifdef DEBUG printf(" vertical %s\n", *vertical ? "on" : "off"); #endif } else if (!strncmp(s, "timesignature", c)) { efindword(s); if ((sscanf(s, "%lu/%lu", ×ig->num, ×ig->denom) != 2) || (&(timesig->denom) == 0) ) { scoterror(Str("Invalid time signature")); timesig->num = 0; timesig->denom = 1; } #ifdef DEBUG printf(" time sig=%lu/%lu\n", timesig->num, timesig->denom); #endif ratstack.num = 4; ratstack.denom = 1; ratmul(timesig, timesig, &ratstack); #ifdef DEBUG printf(" measure length=%f\n", ratval(timesig)); #endif } else if (!strncmp(s, "key", c)) { int y; efindword(s); for (z = 0; z < PITCHCLASSES; z++) key[z] = 0; c = y = 0; for (z = 0; s[z] != (char) 0; z++) switch ((int) s[z]) { case '#': c = y + 1; y++; break; case '-': c = y - 1; y--; break; default: if (!isalpha(s[z])) scoterror(Str("Bad key signature")); key[letterval((int) s[z])] = c; y = 0; } for (z = 0; z < PITCHCLASSES; z++) barkey[z] = key[z]; } else if (!strncmp(s, "transpose", c)) { efindword(s); *transpose = 0; for (z = 0; s[z]; z++) { switch (s[z]) { case ',': (*transpose) -= NOTESPEROCT; break; case '\'': (*transpose) += NOTESPEROCT; break; case '=': (*transpose) = 0; break; case '#': (*transpose)++; break; case '-': (*transpose)--; break; default: (*transpose) += naturals[letterval((int) s[z])]; } } } else if (!strncmp(s, "next", c)) { efindword(s); if (sscanf(s, "p%d", &c) != 1) { scoterror(Str("Invalid field")); efindword(s); break; } efindword(s); if (sscanf(s, "p%d", &z) != 1) { scoterror(Str("Invalid field")); break; } if (*nextlist == NULL) { *nextlist = (Nextp *) malloc(sizeof(Nextp)); nextpp = (*nextlist); nextpp->next = NULL; } else { nextpp = (*nextlist); if ((c == nextpp->dst) || (z == nextpp->src)) scoterror(Str("Nested next-parameter passing")); while (nextpp->next) { nextpp = nextpp->next; if ((c == nextpp->dst) || (z == nextpp->src)) scoterror(Str("Nested next-parameter passing")); } nextpp->next = (Nextp *) malloc(sizeof(Nextp)); nextpp = nextpp->next; nextpp->next = NULL; } nextpp->src = c; nextpp->dst = z; } else scoterror(Str("Unrecognised keyword")); break; case '{': findint(&c); expectchar(':'); if (!c) { ratstack.num = 2L; ratstack.denom = 3L; } else { ratstack.denom = (unsigned long) c; findint(&c); if (!c) { for (z = 1; (unsigned long) z < ratstack.denom; z *= 2); z /= 2; ratstack.num = (unsigned long) z; } else ratstack.num = (unsigned long) c; expectchar(':'); } ratmul(grpmul, grpmul, &ratstack); readinstsec(inst, nextlist, grpmul, timesig, curtime, lastbar, lastnote, notetop, ln, tempop, accidentals, octaves, vertical, key, barkey, transpose, ":"); ratdiv(grpmul, grpmul, &ratstack); expectchar(':'); expectchar('}'); break; case '(': ratass(&ratstack, curtime); if (pn == (*notetop)) { readinstsec(inst, nextlist, grpmul, timesig, curtime, lastbar, lastnote, notetop, ln, tempop, accidentals, octaves, vertical, key, barkey, transpose, ")"); pn = (*notetop); } else { readinstsec(inst, nextlist, grpmul, timesig, curtime, lastbar, lastnote, &pn2->next, ln, tempop, accidentals, octaves, vertical, key, barkey, transpose, ")"); pn = pn2->next; } expectchar(')'); ratass(lastnote, &ratstack); break; case '/': ratadd(lastbar, lastbar, timesig); if ((timesig->num) && (ratcmp(lastbar, curtime))) { scoterror(Str("Wrong number of beats in bar")); ratass(lastbar, curtime); } for (z = 0; z < PITCHCLASSES; z++) barkey[z] = key[z]; break; case '<': if (pn == NULL) { scoterror(Str("Syntax error: cannot back up")); break; } if (pn->next == NULL) { pn->next = (Note *) malloc(sizeof(Note)); initnote(pn->next); pn->next->instrum = pn->instrum + 0.01; } pn2 = pn; pn = pn->next; ratass(curtime, lastnote); break; default: #ifdef DEBUG printf("Reading note\n"); printf(" time=%lu/%lu\n", curtime->num, curtime->denom); printf(" =%f\n", ratval(curtime)); #endif scotungetc(); nn = (Note *) malloc(sizeof(Note)); nn->p = NULL; nn->written = FALSE; if (*notetop == NULL) { pn = (*ln) = (*notetop) = (Note *) malloc(sizeof(Note)); initnote(*notetop); (*notetop)->instrum = (double) inst->number + 0.01; } else if (ratcmp(curtime, lastnote)) pn = (*notetop); nn->instrum = pn->instrum; #ifdef DEBUG printf(" instrument #%f\n", nn->instrum); #endif if (*vertical) strlistcopy(&nn->carryp, &(*ln)->carryp); else strlistcopy(&nn->carryp, &pn->carryp); for (nextpp = (*nextlist); nextpp; nextpp = nextpp->next) { sp = findparam(nextpp->dst, &nn->carryp); if (!strcmp(sp, ".")) strcpy(sp, NEXTP); } ratass(&nn->start, curtime); if (!findint(&c)) { ratstack.num = (unsigned long) c; ratstack.denom = 1L; ratdiv(&nn->dur, &durdiv, &ratstack); ratass(&ratstack, &nn->dur); rattmp.num = 1L; rattmp.denom = 2L; for (;;) { findchar(&c); if (c != '.') break; ratmul(&ratstack, &ratstack, &rattmp); ratadd(&nn->dur, &nn->dur, &ratstack); } } else { if (*vertical) ratass(&nn->dur, &((*ln)->lastdur)); else ratass(&nn->dur, &pn->lastdur); findchar(&c); } ratass(&nn->lastdur, &nn->dur); ratmul(&nn->dur, &nn->dur, grpmul); #ifdef DEBUG printf(" duration=%f\n", ratval(&nn->dur)); printf(" c=%c\n", c); #endif if (c == '=') { nn->octave = 8; lastpitchclass = 0; } else { nn->octave = pn->octave; lastpitchclass = pn->pitchclass; scotungetc(); } for (;;) { findchar(&c); if (c == '\'') nn->octave++; else if (c == ',') nn->octave--; else break; } if (c == 'r') { ratass(lastnote, curtime); ratmul(&rattmp, &nn->lastdur, grpmul); ratadd(curtime, curtime, &rattmp); ratass(&(*ln)->lastdur, &nn->lastdur); ratass(&pn->lastdur, &nn->lastdur); freenote(nn); break; } else { nn->pitchclass = letterval(c); if (*octaves) { c = nn->pitchclass - lastpitchclass; if (c < -(PITCHCLASSES / 2)) nn->octave++; else if (c > PITCHCLASSES / 2) nn->octave--; } } nn->accid = 0; nn->accmod = FALSE; for (;;) { findchar(&c); if (c == '#') { nn->accid++; nn->accmod = TRUE; } else if (c == '-') { nn->accid--; nn->accmod = TRUE; } else if (c == 'n') { nn->accid = 0; nn->accmod = TRUE; } else break; } if (!nn->accmod) nn->accid = barkey[nn->pitchclass]; else if (*accidentals) barkey[nn->pitchclass] = nn->accid; #ifdef DEBUG printf(" transpose=%d\n", *transpose); printf(" octave=%d pitchclass=%d accid=%d transpose=%d pitch=%f\n", nn->octave, nn->pitchclass, nn->accid, *transpose, pitchval(nn->octave, nn->pitchclass, nn->accid, *transpose)); #endif if (c == '_') { findchar(&c); if (c == '_') { nn->tie = TRUE; nn->slur = 0; findchar(&c); } else { nn->slur = 1; nn->tie = FALSE; } } else { nn->slur = 0; nn->tie = FALSE; } if (pn->slur & 1) nn->slur += 2; #ifdef DEBUG printf(" slur=%d tie=%d\n", nn->slur, nn->tie); #endif if (pn->tie) { ratadd(&rattmp, &pn->start, &pn->dur); if (ratcmp(&rattmp, curtime)) scoterror(Str("Improper tie")); if (((nn->octave != pn->octave) || (nn->pitchclass != pn->pitchclass) || ((nn->accid != pn->accid) && (nn->accmod))) && (pitchval(nn->octave, nn->pitchclass, nn->accid, *transpose) != pitchval(pn->octave, pn->pitchclass, pn->accid, *transpose))) scoterror(Str("Tie between different pitches")); ratadd(&pn->dur, &pn->dur, &nn->dur); ratass(&pn->lastdur, &nn->lastdur); pn->slur += nn->slur; pn->tie = nn->tie; freenote(nn); nn = pn; if (c == (char) '[') scoterror(Str("Warning: params changed on tie")); } else { ps = nn->p = (Strlist *) malloc(sizeof(Strlist)); for (z = 0; z < 4; z++) { ps->next = (Strlist *) malloc(sizeof(Strlist)); ps = ps->next; } ps->next = NULL; } ps = nn->p; sprintf(ps->str, "%.02f", nn->instrum); ps = ps->next; sprintf(ps->str, "%g", ratval(&nn->start)); ps = ps->next; sprintf(ps->str, "%g", ratval(&nn->dur)); ps = ps->next; sprintf(ps->str, "%d", nn->slur); ps = ps->next; sprintf(ps->str, "%.02f", pitchval(nn->octave, nn->pitchclass, nn->accid, *transpose)); if (c == '[') { char *pars; int pnum; pars = readparams(inst); #ifdef DEBUG printf("Params: %s\n", pars); #endif z = 0; pnum = 6; while (strchr(" \t\r\n", (int) pars[z])) z++; for (;;) { if (pars[z] == (char) ']') break; c = 0; while (!strchr(" \t\r\n:]", (int) pars[z])) s[c++] = pars[z++]; s[c] = (char) 0; #ifdef DEBUG printf("Read: %s\n", s); #endif while (strchr(" \t\r\n", (int) pars[z])) z++; if (pars[z] == (char) ':') { pnum = atoi(s); if (pnum < 6) scoterror(Str("Parameter number out of range")); z++; while (strchr(" \t\r\n", (int) pars[z])) z++; continue; } #ifdef DEBUG printf("Param #%d: %s\n", pnum, s); #endif if (s[0] == (char) '\'') { addparam(pnum, &s[1], &nn->p); addparam(pnum, ".", &nn->carryp); } else { addparam(pnum, s, &nn->p); addparam(pnum, s, &nn->carryp); } pnum++; } free(pars); } else scotungetc(); if ((nn != pn) && (!pn->written)) { #ifdef DEBUG printf(" doing nextp stuff:\n"); #endif for (nextpp = (*nextlist); nextpp; nextpp = nextpp->next) { #ifdef DEBUG printf(" carrying p%d to p%d?\n", nextpp->src, nextpp->dst); #endif if (!strcmp(findparam(nextpp->dst, &pn->carryp), NEXTP)) { sp = findparam(nextpp->dst, &pn->p); if (!strcmp(sp, ".")) { char *sp2; sp2 = findparam(nextpp->src, &nn->p); if (!strcmp(sp2, ".")) sp2 = findparam(nextpp->src, &nn->carryp); strcpy(sp, sp2); #ifdef DEBUG printf(" Yes.\n"); #endif } } } writenote(pn); } if ((!(*nextlist)) && (!nn->tie)) writenote(nn); if (nn != pn) { if (!pn->written) scoterror(Str("Lost previous note: not written")); #ifdef DEBUG if (pn->next == nn) printf("* pn->next==nn\n"); #endif nn->next = pn->next; #ifdef DEBUG if (pn2 == nn) printf("* pn2==nn\n"); #endif if (pn == *notetop) *notetop = nn; else pn2->next = nn; freenote(pn); pn = nn; #ifdef DEBUG if (nn->next == nn) printf("* Circular list created\n"); #endif } #ifdef DEBUG printf(" nn linked into note list\n"); printf(" curtime=%lu/%lu\n", curtime->num, curtime->denom); printf(" nn->dur=%lu/%lu\n", nn->dur.num, nn->dur.denom); #endif *ln = nn; ratass(lastnote, curtime); ratmul(&rattmp, &nn->lastdur, grpmul); ratadd(curtime, curtime, &rattmp); #ifdef DEBUG printf(" curtime=%lu/%lu\n", curtime->num, curtime->denom); printf(" Done with note\n"); #endif } } scotungetc(); }
int main (int argc, char *argv[]) { short int c; short int readopt=0; short int writeopt=0; short int clearallopt=0; short int onlynote=0; int option_index = 0; /* getopt_long ci mette l'indice delle opzioni */ char arguments[4096]; /* For write */ int hour=0; int minutes=0; int day=0; int month=0; char note[4096]; while (1) { static struct option long_options[] = { {"write", no_argument, 0, 'w'}, {"day", required_argument, 0, 0}, {"month", required_argument, 0, 0}, {"hour", required_argument, 0, 0}, {"minutes", required_argument, 0, 0}, {"note", required_argument, 0, 0}, {"read", no_argument, 0, 'r'}, {"clear", no_argument, 0, 'c'}, {"help", no_argument, 0, 'h'}, {0, 0, 0, 0} }; c=getopt_long(argc, argv, "wrch", long_options, &option_index); if (c==-1) break; switch (c) { case 'w': writeopt=1; break; case 'r': readopt=1; break; case 'c': clearallopt=1; break; case 'h': usage(); return(-1); case 0: if( strcmp( "day", long_options[option_index].name ) == 0 ) { day=atoi(optarg); } else if( strcmp( "month", long_options[option_index].name ) == 0 ) { month=atoi(optarg); } else if( strcmp( "hour", long_options[option_index].name ) == 0 ) { hour=atoi(optarg); } else if( strcmp( "minutes", long_options[option_index].name ) == 0 ) { minutes=atoi(optarg); } else if( strcmp( "note", long_options[option_index].name ) == 0 ) { strcpy(note,optarg); } break; case '?': usage(); return(-1); default: usage(); return(-1); } } /* 1 opzione alla volta */ if ((writeopt&&readopt)||(writeopt&&clearallopt)||(clearallopt&&readopt)){ usage(); return -1; } if (readopt) { readnotes(); } else if (clearallopt) { clearallnotes(); } else if (writeopt) { if ((day+month+hour+minutes)==0) onlynote=1; //printf ("hour %d,minutes %d,day %d,month %d,note %s",hour,minutes,day,month,note);return 0; writenote (onlynote,hour,minutes,day,month,note); readnotes(); } return (0); }
int elfcore(int fd, FILE *fp, const char *path, long coresize) { procfs_sysinfo *sysinfo; int sysinfo_len; procfs_info info; procfs_status status; int ret; procfs_mapinfo *mem = NULL, *mapinfos = NULL, *ldd_infos = NULL; int numnote=0, num, i, j, seg = 0, err, n_ldd_infos = 0; Elf32_Ehdr elf; Elf32_Phdr phdr; struct memelfnote notes[20], thread_note; off_t offset = 0, dataoff; uint64_t cur_tid_base = 0, cur_tid_size = 0; if (nodumpmem) { if (-1 == get_ldd_mapinfos(fd, &ldd_infos, &n_ldd_infos)) { /* should we bail out here? */ n_ldd_infos = 0; } } if((ret = devctl(fd, DCMD_PROC_SYSINFO, 0, 0, &sysinfo_len)) != EOK) { errno = ret; goto bailout; } if(sysinfo = alloca(sysinfo_len)) { if((ret = devctl(fd, DCMD_PROC_SYSINFO, sysinfo, sysinfo_len, 0)) != EOK) { errno = ret; goto bailout; } } if((ret = devctl(fd, DCMD_PROC_INFO, &info, sizeof info, 0)) != EOK) { errno = ret; goto bailout; } pagesize = sysconf( _SC_PAGESIZE ); if ( membuf == NULL && ((membuf = malloc( pagesize )) == NULL) ) { goto bailout; } // write elf header memcpy(elf.e_ident, ELFMAG, SELFMAG); elf.e_ident[EI_CLASS] = ELFCLASS32; elf.e_ident[EI_DATA] = ELFDATANATIVE; elf.e_ident[EI_VERSION] = EV_CURRENT; #if defined (__ARM__) elf.e_ident[EI_OSABI] = ELFOSABI_ARM; #endif memset(elf.e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD); if((ret = devctl(fd, DCMD_PROC_PAGEDATA, NULL, 0, &num)) != EOK) { errno = ret; goto bailout; } mapinfos = malloc( num * sizeof *mem ); if ( mapinfos == NULL ) { goto bailout; } if((ret = devctl(fd, DCMD_PROC_PAGEDATA, mapinfos, num*sizeof(*mapinfos), &num)) != EOK) { errno = ret; goto bailout; } mem = malloc( (n_ldd_infos + num) * sizeof(*mem) ); if ( mem == NULL ) { goto bailout; } /* find the offending thread */ for(status.tid = 1; devctl(fd, DCMD_PROC_TIDSTATUS, &status, sizeof status, 0) == EOK; status.tid++) { dprintf(("thread %d.flags is %#x\n", status.tid, status.flags )); if(status.why == _DEBUG_WHY_SIGNALLED) { // This is the faulting thread... dprintf(("thread %d is was SIGNALLED\n", status.tid )); cur_tid = status.tid; cur_tid_base = status.stkbase; cur_tid_size = status.stksize; } dprintf(("thread %d.why is %#x\n", status.tid, status.why )); } if(cur_tid == 0) { /* can't find the faulting thread then we need to dump all stack information */ cur_tid_only = 0; } for(seg = 0, i = 0; i < num; i++) { if(!(mapinfos[i].flags & PG_HWMAPPED) || (nodumpmem && !(mapinfos[i].flags & MAP_STACK)) ) { continue; } if ( (nodumpphys && (mapinfos[i].flags & MAP_PHYS) && !(mapinfos[i].flags & MAP_ANON)) ) { continue; } /* if we only want to dump the offending tid's stack */ if(cur_tid_only && (mapinfos[i].flags & MAP_STACK) && !OFFENDING_THREAD(cur_tid_base, cur_tid_size, &mapinfos[i])) { continue; } memcpy(&mem[seg], &mapinfos[i], sizeof(*mem)); seg++; } dprintf(("ldd mapinfos:\n")); for(i = 0; i < n_ldd_infos; i++) { dprintf(("%svaddr=%#llx, offset=%#llx, size=%#llx, flags=%#x\n", ldd_infos[i].flags & PG_HWMAPPED?"*":"", ldd_infos[i].vaddr, ldd_infos[i].offset, ldd_infos[i].size, ldd_infos[i].flags )); memcpy( &mem[seg], &ldd_infos[i], sizeof(*mem));; seg++; } free(mapinfos); mapinfos = NULL; if(n_ldd_infos) { free(ldd_infos); ldd_infos = NULL; } num = seg; elf.e_type = ET_CORE; elf.e_machine = EM_NATIVE; elf.e_version = EV_CURRENT; elf.e_entry = 0; elf.e_phoff = sizeof(elf); elf.e_shoff = 0; #ifdef __SH__ { struct cpuinfo_entry *cpu; cpu = SYSPAGE_ENTRY(cpuinfo); switch ( SH4_PVR_FAM(cpu[0].cpu) ) { case SH4_PVR_SH4A: dprintf(("Noting SH4-A CPU\n")); elf.e_flags = EF_SH4A; break; case SH4_PVR_SH4: default: elf.e_flags = EF_SH4; break; } } #else elf.e_flags = 0; #endif elf.e_ehsize = sizeof(elf); elf.e_phentsize = sizeof(phdr); elf.e_phnum = seg+1; /* xxxx */ elf.e_shentsize = 0; elf.e_shnum = 0; elf.e_shstrndx = 0; if(dump_write( fp, &elf, sizeof elf, &coresize ) == -1) goto bailout; offset += sizeof elf; offset += (elf.e_phnum) * sizeof phdr; if(sysinfo) { // write QNT_CORE_SYSINFO note memset( notes, 0, sizeof notes ); notes[numnote].name = QNX_NOTE_NAME; notes[numnote].type = QNT_CORE_SYSINFO; notes[numnote].datasz = roundup(sysinfo_len, sizeof (Elf32_Word)); notes[numnote].data = sysinfo; numnote++; } // write QNT_CORE_INFO note notes[numnote].name = QNX_NOTE_NAME; notes[numnote].type = QNT_CORE_INFO; notes[numnote].datasz = sizeof(info); notes[numnote].data = &info; numnote++; /* Write notes phdr entry */ { int sz = 0; memset( &phdr, 0, sizeof phdr ); for(i = 0; i < numnote; i++) sz += notesize(¬es[i]); for(status.tid = 1; devctl(fd, DCMD_PROC_TIDSTATUS, &status, sizeof status, 0) == EOK; status.tid++) { procfs_greg greg; procfs_fpreg fpreg; int size; if ( (err = devctl(fd, DCMD_PROC_CURTHREAD, &status.tid, sizeof status.tid, 0 )) != EOK ) { continue; } if (cur_tid_only && (cur_tid != status.tid)) { continue; } fixup_stack_boundary( &status, mem, seg ); thread_note.name = QNX_NOTE_NAME; thread_note.type = QNT_CORE_STATUS; thread_note.datasz = sizeof(status); thread_note.data = &status; sz += notesize( &thread_note ); if(devctl(fd, DCMD_PROC_GETGREG, &greg, sizeof greg, &size) == EOK) { thread_note.name = QNX_NOTE_NAME; thread_note.type = QNT_CORE_GREG; thread_note.datasz = size; thread_note.data = &greg; sz += notesize( &thread_note ); } if(devctl(fd, DCMD_PROC_GETFPREG, &fpreg, sizeof fpreg, &size) == EOK) { thread_note.name = QNX_NOTE_NAME; thread_note.type = QNT_CORE_FPREG; thread_note.datasz = size; thread_note.data = &fpreg; sz += notesize( &thread_note ); } } phdr.p_type = PT_NOTE; phdr.p_offset = offset; phdr.p_vaddr = 0; phdr.p_paddr = 0; phdr.p_filesz = sz; phdr.p_memsz = 0; phdr.p_flags = 0; phdr.p_align = 0; offset += phdr.p_filesz; if(dump_write( fp, &phdr, sizeof(phdr), &coresize) == -1) goto bailout; } /* Page-align dumped data */ dataoff = offset = roundup(offset, pagesize); for ( i = 0; i < seg; i++ ) { memset( &phdr, 0, sizeof phdr ); phdr.p_type = PT_LOAD; phdr.p_offset = offset; phdr.p_vaddr = mem[i].vaddr; phdr.p_paddr = 0; phdr.p_memsz = mem[i].size; phdr.p_flags = PF_W|PF_R; if ( mem[i].flags & MAP_ELF ) phdr.p_flags |= PF_X; phdr.p_align = pagesize; phdr.p_filesz = phdr.p_memsz; offset += phdr.p_filesz; if(dump_write( fp, &phdr, sizeof(phdr), &coresize) == -1) goto bailout; } for(i = 0; i < numnote; i++) { if (!writenote(¬es[i], fp, &coresize )) goto bailout; } for(status.tid = 1; devctl(fd, DCMD_PROC_TIDSTATUS, &status, sizeof status, 0) == EOK; status.tid++) { procfs_greg greg; procfs_fpreg fpreg; int size; if ( devctl(fd, DCMD_PROC_CURTHREAD, &status.tid, sizeof status.tid, 0 ) != EOK ) { continue; } if ( cur_tid == 0 ) cur_tid = status.tid; if (cur_tid_only && (cur_tid != status.tid)) { continue; } else if ( status.tid == cur_tid ) { dprintf(("thread %d is current thread!\n", status.tid )); slog_tid( &status, path ); status.flags |= _DEBUG_FLAG_CURTID; } // write QNT_CORE_STATUS note thread_note.name = QNX_NOTE_NAME; thread_note.type = QNT_CORE_STATUS; thread_note.datasz = sizeof(status); thread_note.data = &status; if ( !writenote( &thread_note, fp, &coresize ) ) goto bailout; if(devctl(fd, DCMD_PROC_GETGREG, &greg, sizeof greg, &size) == EOK) { // write QNT_CORE_GREG note thread_note.name = QNX_NOTE_NAME; thread_note.type = QNT_CORE_GREG; thread_note.datasz = size; thread_note.data = &greg; if ( !writenote( &thread_note, fp, &coresize ) ) goto bailout; } if(devctl(fd, DCMD_PROC_GETFPREG, &fpreg, sizeof fpreg, &size) == EOK) { // write QNT_CORE_FPREG note thread_note.name = QNX_NOTE_NAME; thread_note.type = QNT_CORE_FPREG; thread_note.datasz = size; thread_note.data = &fpreg; if ( !writenote( &thread_note, fp, &coresize ) ) goto bailout; } } dump_seek( fp, dataoff ); for ( j = 0; j < seg; j++ ) { if ( lseek( fd, mem[j].vaddr, SEEK_SET ) == -1 ) goto bailout; if ( mem[j].flags & MAP_STACK ) dump_stack_memory( fd, fp, &mem[j], &coresize ); else if (!nodumpmem) dump_memory( fd, fp, &mem[j], &coresize ); } // Return EOK when accually writing ELF files free(mem); return EOK; bailout: if ( mapinfos != NULL ) { free(mapinfos); } if ( ldd_infos != NULL ) { free(ldd_infos); } if ( mem != NULL ) { free(mem); } return errno; }
/* * Actual dumper * * This is a two-pass process; first we find the offsets of the bits, * and then they are actually written out. If we run out of core limit * we just truncate. */ static int elf_core_dump(long signr, struct pt_regs * regs) { int has_dumped = 0; struct file file; struct dentry *dentry; struct inode *inode; mm_segment_t fs; char corefile[6+sizeof(current->comm)]; int segs; int i; size_t size; struct vm_area_struct *vma; struct elfhdr elf; off_t offset = 0, dataoff; unsigned long limit = current->rlim[RLIMIT_CORE].rlim_cur; int numnote = 4; struct memelfnote notes[4]; struct elf_prstatus prstatus; /* NT_PRSTATUS */ elf_fpregset_t fpu; /* NT_PRFPREG */ struct elf_prpsinfo psinfo; /* NT_PRPSINFO */ if (!current->dumpable || limit < ELF_EXEC_PAGESIZE || atomic_read(¤t->mm->count) != 1) return 0; current->dumpable = 0; #ifndef CONFIG_BINFMT_ELF MOD_INC_USE_COUNT; #endif /* Count what's needed to dump, up to the limit of coredump size */ segs = 0; size = 0; for(vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) { if (maydump(vma)) { unsigned long sz = vma->vm_end-vma->vm_start; if (size+sz >= limit) break; else size += sz; } segs++; } #ifdef DEBUG printk("elf_core_dump: %d segs taking %d bytes\n", segs, size); #endif /* Set up header */ memcpy(elf.e_ident, ELFMAG, SELFMAG); elf.e_ident[EI_CLASS] = ELF_CLASS; elf.e_ident[EI_DATA] = ELF_DATA; elf.e_ident[EI_VERSION] = EV_CURRENT; memset(elf.e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD); elf.e_type = ET_CORE; elf.e_machine = ELF_ARCH; elf.e_version = EV_CURRENT; elf.e_entry = 0; elf.e_phoff = sizeof(elf); elf.e_shoff = 0; elf.e_flags = 0; elf.e_ehsize = sizeof(elf); elf.e_phentsize = sizeof(struct elf_phdr); elf.e_phnum = segs+1; /* Include notes */ elf.e_shentsize = 0; elf.e_shnum = 0; elf.e_shstrndx = 0; fs = get_fs(); set_fs(KERNEL_DS); memcpy(corefile,"core.",5); #if 0 memcpy(corefile+5,current->comm,sizeof(current->comm)); #else corefile[4] = '\0'; #endif dentry = open_namei(corefile, O_CREAT | 2 | O_TRUNC | O_NOFOLLOW, 0600); if (IS_ERR(dentry)) { dentry = NULL; goto end_coredump; } inode = dentry->d_inode; if(inode->i_nlink > 1) goto end_coredump; /* multiple links - don't dump */ if (!S_ISREG(inode->i_mode)) goto end_coredump; if (!inode->i_op || !inode->i_op->default_file_ops) goto end_coredump; if (init_private_file(&file, dentry, 3)) goto end_coredump; if (!file.f_op->write) goto close_coredump; has_dumped = 1; current->flags |= PF_DUMPCORE; DUMP_WRITE(&elf, sizeof(elf)); offset += sizeof(elf); /* Elf header */ offset += (segs+1) * sizeof(struct elf_phdr); /* Program headers */ /* * Set up the notes in similar form to SVR4 core dumps made * with info from their /proc. */ memset(&psinfo, 0, sizeof(psinfo)); memset(&prstatus, 0, sizeof(prstatus)); notes[0].name = "CORE"; notes[0].type = NT_PRSTATUS; notes[0].datasz = sizeof(prstatus); notes[0].data = &prstatus; prstatus.pr_info.si_signo = prstatus.pr_cursig = signr; prstatus.pr_sigpend = current->signal.sig[0]; prstatus.pr_sighold = current->blocked.sig[0]; psinfo.pr_pid = prstatus.pr_pid = current->pid; psinfo.pr_ppid = prstatus.pr_ppid = current->p_pptr->pid; psinfo.pr_pgrp = prstatus.pr_pgrp = current->pgrp; psinfo.pr_sid = prstatus.pr_sid = current->session; prstatus.pr_utime.tv_sec = CT_TO_SECS(current->times.tms_utime); prstatus.pr_utime.tv_usec = CT_TO_USECS(current->times.tms_utime); prstatus.pr_stime.tv_sec = CT_TO_SECS(current->times.tms_stime); prstatus.pr_stime.tv_usec = CT_TO_USECS(current->times.tms_stime); prstatus.pr_cutime.tv_sec = CT_TO_SECS(current->times.tms_cutime); prstatus.pr_cutime.tv_usec = CT_TO_USECS(current->times.tms_cutime); prstatus.pr_cstime.tv_sec = CT_TO_SECS(current->times.tms_cstime); prstatus.pr_cstime.tv_usec = CT_TO_USECS(current->times.tms_cstime); /* * This transfers the registers from regs into the standard * coredump arrangement, whatever that is. */ #ifdef ELF_CORE_COPY_REGS ELF_CORE_COPY_REGS(prstatus.pr_reg, regs) #else if (sizeof(elf_gregset_t) != sizeof(struct pt_regs)) { printk("sizeof(elf_gregset_t) (%ld) != sizeof(struct pt_regs) (%ld)\n", (long)sizeof(elf_gregset_t), (long)sizeof(struct pt_regs)); } else *(struct pt_regs *)&prstatus.pr_reg = *regs; #endif #ifdef DEBUG dump_regs("Passed in regs", (elf_greg_t *)regs); dump_regs("prstatus regs", (elf_greg_t *)&prstatus.pr_reg); #endif notes[1].name = "CORE"; notes[1].type = NT_PRPSINFO; notes[1].datasz = sizeof(psinfo); notes[1].data = &psinfo; i = current->state ? ffz(~current->state) + 1 : 0; psinfo.pr_state = i; psinfo.pr_sname = (i < 0 || i > 5) ? '.' : "RSDZTD"[i]; psinfo.pr_zomb = psinfo.pr_sname == 'Z'; psinfo.pr_nice = current->priority-15; psinfo.pr_flag = current->flags; psinfo.pr_uid = current->uid; psinfo.pr_gid = current->gid; { int i, len; set_fs(fs); len = current->mm->arg_end - current->mm->arg_start; if (len >= ELF_PRARGSZ) len = ELF_PRARGSZ-1; copy_from_user(&psinfo.pr_psargs, (const char *)current->mm->arg_start, len); for(i = 0; i < len; i++) if (psinfo.pr_psargs[i] == 0) psinfo.pr_psargs[i] = ' '; psinfo.pr_psargs[len] = 0; set_fs(KERNEL_DS); } strncpy(psinfo.pr_fname, current->comm, sizeof(psinfo.pr_fname)); notes[2].name = "CORE"; notes[2].type = NT_TASKSTRUCT; notes[2].datasz = sizeof(*current); notes[2].data = current; /* Try to dump the FPU. */ prstatus.pr_fpvalid = dump_fpu (regs, &fpu); if (!prstatus.pr_fpvalid) { numnote--; } else { notes[3].name = "CORE"; notes[3].type = NT_PRFPREG; notes[3].datasz = sizeof(fpu); notes[3].data = &fpu; } /* Write notes phdr entry */ { struct elf_phdr phdr; int sz = 0; for(i = 0; i < numnote; i++) sz += notesize(¬es[i]); phdr.p_type = PT_NOTE; phdr.p_offset = offset; phdr.p_vaddr = 0; phdr.p_paddr = 0; phdr.p_filesz = sz; phdr.p_memsz = 0; phdr.p_flags = 0; phdr.p_align = 0; offset += phdr.p_filesz; DUMP_WRITE(&phdr, sizeof(phdr)); } /* Page-align dumped data */ dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE); /* Write program headers for segments dump */ for(vma = current->mm->mmap, i = 0; i < segs && vma != NULL; vma = vma->vm_next) { struct elf_phdr phdr; size_t sz; i++; sz = vma->vm_end - vma->vm_start; phdr.p_type = PT_LOAD; phdr.p_offset = offset; phdr.p_vaddr = vma->vm_start; phdr.p_paddr = 0; phdr.p_filesz = maydump(vma) ? sz : 0; phdr.p_memsz = sz; offset += phdr.p_filesz; phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0; if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W; if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X; phdr.p_align = ELF_EXEC_PAGESIZE; DUMP_WRITE(&phdr, sizeof(phdr)); } for(i = 0; i < numnote; i++) if (!writenote(¬es[i], &file)) goto close_coredump; set_fs(fs); DUMP_SEEK(dataoff); for(i = 0, vma = current->mm->mmap; i < segs && vma != NULL; vma = vma->vm_next) { unsigned long addr = vma->vm_start; unsigned long len = vma->vm_end - vma->vm_start; i++; if (!maydump(vma)) continue; #ifdef DEBUG printk("elf_core_dump: writing %08lx %lx\n", addr, len); #endif DUMP_WRITE((void *)addr, len); } if ((off_t) file.f_pos != offset) { /* Sanity check */ printk("elf_core_dump: file.f_pos (%ld) != offset (%ld)\n", (off_t) file.f_pos, offset); } close_coredump: if (file.f_op->release) file.f_op->release(inode,&file); end_coredump: set_fs(fs); dput(dentry); #ifndef CONFIG_BINFMT_ELF MOD_DEC_USE_COUNT; #endif return has_dumped; }
/* Actual dumper. * * This is a two-pass process; first we find the offsets of the bits, * and then they are actually written out. If we run out of core limit * we just truncate. */ static int irix_core_dump(long signr, struct pt_regs * regs, struct file *file) { int has_dumped = 0; mm_segment_t fs; int segs; int i; size_t size; struct vm_area_struct *vma; struct elfhdr elf; off_t offset = 0, dataoff; int limit = current->rlim[RLIMIT_CORE].rlim_cur; int numnote = 4; struct memelfnote notes[4]; struct elf_prstatus prstatus; /* NT_PRSTATUS */ elf_fpregset_t fpu; /* NT_PRFPREG */ struct elf_prpsinfo psinfo; /* NT_PRPSINFO */ /* Count what's needed to dump, up to the limit of coredump size. */ segs = 0; size = 0; for(vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) { if (maydump(vma)) { int sz = vma->vm_end-vma->vm_start; if (size+sz >= limit) break; else size += sz; } segs++; } #ifdef DEBUG printk("irix_core_dump: %d segs taking %d bytes\n", segs, size); #endif /* Set up header. */ memcpy(elf.e_ident, ELFMAG, SELFMAG); elf.e_ident[EI_CLASS] = ELFCLASS32; elf.e_ident[EI_DATA] = ELFDATA2LSB; elf.e_ident[EI_VERSION] = EV_CURRENT; memset(elf.e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD); elf.e_type = ET_CORE; elf.e_machine = ELF_ARCH; elf.e_version = EV_CURRENT; elf.e_entry = 0; elf.e_phoff = sizeof(elf); elf.e_shoff = 0; elf.e_flags = 0; elf.e_ehsize = sizeof(elf); elf.e_phentsize = sizeof(struct elf_phdr); elf.e_phnum = segs+1; /* Include notes. */ elf.e_shentsize = 0; elf.e_shnum = 0; elf.e_shstrndx = 0; fs = get_fs(); set_fs(KERNEL_DS); has_dumped = 1; current->flags |= PF_DUMPCORE; DUMP_WRITE(&elf, sizeof(elf)); offset += sizeof(elf); /* Elf header. */ offset += (segs+1) * sizeof(struct elf_phdr); /* Program headers. */ /* Set up the notes in similar form to SVR4 core dumps made * with info from their /proc. */ memset(&psinfo, 0, sizeof(psinfo)); memset(&prstatus, 0, sizeof(prstatus)); notes[0].name = "CORE"; notes[0].type = NT_PRSTATUS; notes[0].datasz = sizeof(prstatus); notes[0].data = &prstatus; prstatus.pr_info.si_signo = prstatus.pr_cursig = signr; prstatus.pr_sigpend = current->pending.signal.sig[0]; prstatus.pr_sighold = current->blocked.sig[0]; psinfo.pr_pid = prstatus.pr_pid = current->pid; psinfo.pr_ppid = prstatus.pr_ppid = current->p_pptr->pid; psinfo.pr_pgrp = prstatus.pr_pgrp = current->pgrp; psinfo.pr_sid = prstatus.pr_sid = current->session; prstatus.pr_utime.tv_sec = CT_TO_SECS(current->times.tms_utime); prstatus.pr_utime.tv_usec = CT_TO_USECS(current->times.tms_utime); prstatus.pr_stime.tv_sec = CT_TO_SECS(current->times.tms_stime); prstatus.pr_stime.tv_usec = CT_TO_USECS(current->times.tms_stime); prstatus.pr_cutime.tv_sec = CT_TO_SECS(current->times.tms_cutime); prstatus.pr_cutime.tv_usec = CT_TO_USECS(current->times.tms_cutime); prstatus.pr_cstime.tv_sec = CT_TO_SECS(current->times.tms_cstime); prstatus.pr_cstime.tv_usec = CT_TO_USECS(current->times.tms_cstime); if (sizeof(elf_gregset_t) != sizeof(struct pt_regs)) { printk("sizeof(elf_gregset_t) (%d) != sizeof(struct pt_regs) " "(%d)\n", sizeof(elf_gregset_t), sizeof(struct pt_regs)); } else { *(struct pt_regs *)&prstatus.pr_reg = *regs; } notes[1].name = "CORE"; notes[1].type = NT_PRPSINFO; notes[1].datasz = sizeof(psinfo); notes[1].data = &psinfo; i = current->state ? ffz(~current->state) + 1 : 0; psinfo.pr_state = i; psinfo.pr_sname = (i < 0 || i > 5) ? '.' : "RSDZTD"[i]; psinfo.pr_zomb = psinfo.pr_sname == 'Z'; psinfo.pr_nice = current->nice; psinfo.pr_flag = current->flags; psinfo.pr_uid = current->uid; psinfo.pr_gid = current->gid; { int i, len; set_fs(fs); len = current->mm->arg_end - current->mm->arg_start; len = len >= ELF_PRARGSZ ? ELF_PRARGSZ : len; copy_from_user(&psinfo.pr_psargs, (const char *)current->mm->arg_start, len); for(i = 0; i < len; i++) if (psinfo.pr_psargs[i] == 0) psinfo.pr_psargs[i] = ' '; psinfo.pr_psargs[len] = 0; set_fs(KERNEL_DS); } strncpy(psinfo.pr_fname, current->comm, sizeof(psinfo.pr_fname)); notes[2].name = "CORE"; notes[2].type = NT_TASKSTRUCT; notes[2].datasz = sizeof(*current); notes[2].data = current; /* Try to dump the FPU. */ prstatus.pr_fpvalid = dump_fpu (&fpu); if (!prstatus.pr_fpvalid) { numnote--; } else { notes[3].name = "CORE"; notes[3].type = NT_PRFPREG; notes[3].datasz = sizeof(fpu); notes[3].data = &fpu; } /* Write notes phdr entry. */ { struct elf_phdr phdr; int sz = 0; for(i = 0; i < numnote; i++) sz += notesize(¬es[i]); phdr.p_type = PT_NOTE; phdr.p_offset = offset; phdr.p_vaddr = 0; phdr.p_paddr = 0; phdr.p_filesz = sz; phdr.p_memsz = 0; phdr.p_flags = 0; phdr.p_align = 0; offset += phdr.p_filesz; DUMP_WRITE(&phdr, sizeof(phdr)); } /* Page-align dumped data. */ dataoff = offset = roundup(offset, PAGE_SIZE); /* Write program headers for segments dump. */ for(vma = current->mm->mmap, i = 0; i < segs && vma != NULL; vma = vma->vm_next) { struct elf_phdr phdr; size_t sz; i++; sz = vma->vm_end - vma->vm_start; phdr.p_type = PT_LOAD; phdr.p_offset = offset; phdr.p_vaddr = vma->vm_start; phdr.p_paddr = 0; phdr.p_filesz = maydump(vma) ? sz : 0; phdr.p_memsz = sz; offset += phdr.p_filesz; phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0; if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W; if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X; phdr.p_align = PAGE_SIZE; DUMP_WRITE(&phdr, sizeof(phdr)); } for(i = 0; i < numnote; i++) if (!writenote(¬es[i], file)) goto end_coredump; set_fs(fs); DUMP_SEEK(dataoff); for(i = 0, vma = current->mm->mmap; i < segs && vma != NULL; vma = vma->vm_next) { unsigned long addr = vma->vm_start; unsigned long len = vma->vm_end - vma->vm_start; if (!maydump(vma)) continue; i++; #ifdef DEBUG printk("elf_core_dump: writing %08lx %lx\n", addr, len); #endif DUMP_WRITE((void *)addr, len); } if ((off_t) file->f_pos != offset) { /* Sanity check. */ printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n", (off_t) file->f_pos, offset); } end_coredump: set_fs(fs); return has_dumped; }