#!/usr/bin/env l1
// dump information about a core file
// usage: coreinfo.cqct <corefile>

@include <elf.cqct>

@define align(l, sz)
{
	@local res;

	res = l;
	if (l % sz)
		res = l + (sz - (l % sz));

	return res;
}

@define ntype2str(elfdom, ntype)
{
	@local s;
	
	switch(ntype) {
	case elfdom`NT_PRSTATUS:
		s = "NT_PRSTATUS (prstatus structure)";
		break;
	case elfdom`NT_FPREGSET:
		s = "NT_FPREGSET (floating point registers)";
		break;
	case elfdom`NT_PRPSINFO:
		s = "NT_PRPSINFO (prpsinfo structure)";
		break;
	case elfdom`NT_PRXREG:
		s = "NT_PRXREG";
		break;
	case elfdom`NT_TASKSTRUCT:
		s = "NT_TASKSTRUCT";
		break;
	case elfdom`NT_PLATFORM:
		s = "NT_PLATFORM";
		break;
	case elfdom`NT_AUXV:
		s = "NT_AUXV (auxiliary vector)";
		break;
	case elfdom`NT_GWINDOWS:
		s = "NT_GWINDOWS";
		break;
	case elfdom`NT_ASRS:
		s = "NT_ASRS";
		break;
	case elfdom`NT_PSTATUS:
		s = "NT_PSTATUS";
		break;
	case elfdom`NT_PSINFO:
		s = "NT_PSINFO";
		break;
	case elfdom`NT_PRCRED:
		s = "NT_PRCRED";
		break;
	case elfdom`NT_UTSNAME:
		s = "NT_UTSNAME";
		break;
	case elfdom`NT_LWPSTATUS:
		s = "NT_LWPSTATUS";
		break;
	case elfdom`NT_LWPSINFO:
		s = "NT_LWPSINFO";
		break;
	case elfdom`NT_PRFPXREG:
		s = "NT_PRFPXREG";
		break;
	case elfdom`NT_VERSION:
		s = "NT_VERSION";
		break;
	case elfdom`NT_PRXFPREG:
		s = "NT_PRXFPREG (user_xfpregs structure)";
		break;
	case elfdom`NT_PPC_VMX:
		s = "NT_PPC_VMX";
		break;
	default:
		s = sprintfa("UNKNOWN: 0x%x", ntype);
	}
	
	return s;
}


@define main(args)
{
	@local elfdom, infile;
	@local ehdr;
	@local pharray, p, i, is32;

	if (length(args) != 1) {
		printf("usage: coreinfo.cqct <corefile>\n");
		return -1;
	}
	
	infile = listref(args, 0);

	elfdom = mkelfrec(mapfile(infile)).elf;

	if (sizeof (nsptr (elfdom.ns)) == 4) {
		ehdr = (elfdom`Elf32_Ehdr *){elfdom} 0;
		pharray = (elfdom`Elf32_Phdr *) ehdr->e_phoff;
		is32 = 1;
	}
	else {
		ehdr = (elfdom`Elf64_Ehdr *){elfdom} 0;
		pharray = (elfdom`Elf64_Phdr *) ehdr->e_phoff;		
		is32 = 0;
	}

	if (ehdr->e_type != elfdom`ET_CORE) {
		printf("Are you sure %s is a corefile?\n", infile);
		return -1;
	}

	for (i = 0; i < ehdr->e_phnum; i++) {
		p = pharray + i;
		if (p->p_type == elfdom`PT_NOTE) {
			@local cur, cnt;

			cur = p->p_offset; 
			cnt = 0;
			while (cur  < p->p_offset +  p->p_filesz) {
				@local nhdr; 

				if (is32) {
					nhdr = (elfdom`Elf32_Nhdr *) cur;
				}
				else {
					nhdr = (elfdom`Elf64_Nhdr *) cur;
				}
				
				printf("Note %d (%s) is:  ", cnt, (char *){elfdom}(cur + sizeof(*nhdr)));
				// cur is now data beginning
				cur = cur + sizeof(*nhdr) + align(nhdr->n_namesz, 4);

				if (nhdr->n_type == elfdom`NT_PRPSINFO) {
					@local prpsinfo;

					prpsinfo = nil;
					if (nhdr->n_descsz == sizeof(struct elfdom`elf_prpsinfo_32)) {
						printf("32-bit PRPSINFO:\n");
						prpsinfo = (struct elfdom`elf_prpsinfo_32 *)cur;
					}
					else if (nhdr->n_descsz == sizeof(struct elfdom`elf_prpsinfo_64)) {
						printf("64-bit PRPSINFO:\n");
						prpsinfo = (struct elfdom`elf_prpsinfo_64 *)cur;
					}
					else if (nhdr->n_descsz == sizeof(struct elfdom`compat_elf_prpsinfo)) {
						printf("compat PRPSINFO:\n");
						prpsinfo = (struct elfdom`compat_elf_prpsinfo *)cur;
					}
					if(isnil(prpsinfo)) {
						printf("%s of unknown size %d.\n", ntype2str(elfdom, nhdr->n_type), 
						       nhdr->n_descsz);
					}
					else {
						printf("\tpr_state:  %d\n", prpsinfo->pr_state);
						printf("\tpr_sname:  %d\n", prpsinfo->pr_sname);
						printf("\tpr_zomb:   %d\n", prpsinfo->pr_zomb);
						printf("\tpr_nice:   %d\n", prpsinfo->pr_nice);
						printf("\tpr_flag:   %d\n", prpsinfo->pr_flag);
						printf("\tpr_uid:    %d\n", prpsinfo->pr_uid);
						printf("\tpr_gid:    %d\n", prpsinfo->pr_gid);
						printf("\tpr_pid:    %d\n", prpsinfo->pr_pid);
						printf("\tpr_ppid:   %d\n", prpsinfo->pr_ppid);
						printf("\tpr_pgrp:   %d\n", prpsinfo->pr_pgrp);
						printf("\tpr_sid:    %d\n", prpsinfo->pr_sid);
						printf("\tpr_fname:  %s\n", prpsinfo->pr_fname);
						printf("\tpr_psargs: %s\n", prpsinfo->pr_psargs);
					}
				}
				else if (nhdr->n_type == elfdom`NT_PRSTATUS) {
					@local prstatus;
					
					prstatus = nil;
					
					if (nhdr->n_descsz == sizeof(struct elfdom`elf_prstatus_32)) {
						printf("32-bit PRSTATUS:\n");
						prstatus = (struct elfdom`elf_prstatus_32 *)cur;
					}
					else if (nhdr->n_descsz == sizeof(struct elfdom`elf_prstatus_64)) {
						printf("64-bit PRSTATUS:\n");
						prstatus = (struct elfdom`elf_prstatus_64 *)cur;
					}
					if (isnil(prstatus)) {
						printf("%s of unknown size %d.\n", ntype2str(elfdom, nhdr->n_type), 
						       nhdr->n_descsz);
					}
					else {
						printf("\tpr_cursig: %d\n", prstatus->pr_cursig);
						printf("\tpr_pid:    %d\n", prstatus->pr_pid);
						printf("\tpr_ppid:   %d\n", prstatus->pr_ppid);
						printf("\tpr_pgrp:   %d\n", prstatus->pr_pgrp);
						printf("\tpr_sid:    %d\n", prstatus->pr_sid);
						for(j = 0; j < sizeof(prstatus->pr_reg) / sizeof(prstatus->pr_reg[0]); j++) {
							printf("\treg %2d:    0x%.8x\n", j, prstatus->pr_reg[j]);
						}
						printf("\tpr_fpvalid %d\n", prstatus->pr_fpvalid);
					}
				}
				else {
					printf("%s of unknown size %d.\n", ntype2str(elfdom, nhdr->n_type), 
					       nhdr->n_descsz);
				}
				// next section
				cur = cur + align(nhdr->n_descsz, 4);
				cnt++;
			}			
			
			break;
		}
	}
}

return main(args);