static store_error_t store_get_span(const store_t *store, uint64_t irecord, int32_t *itmin, int32_t *nsamples, int *is_zero) { record_t *record; if (irecord >= store->nrecords) { return INVALID_RECORD; } record = &store->records[irecord]; *itmin = xe32toh(record->itmin); *nsamples = xe32toh(record->nsamples); *is_zero = REC_ZERO == xe64toh(record->data_offset); if (!inlimits(*itmin) || !inposlimits(*nsamples)) { return BAD_RECORD; } return SUCCESS; }
static store_error_t store_init(int f_index, int f_data, store_t *store) { void *p; struct stat st; size_t mmap_index_size; int use_mmap; use_mmap = 0; *store = ZERO_STORE; store->f_index = f_index; store->f_data = f_data; if (8 != pread(store->f_index, &store->nrecords, 8, 0)) { return READ_INDEX_FAILED; } if (4 != pread(store->f_index, &store->deltat, 4, 8)) { return READ_INDEX_FAILED; } store->nrecords = xe64toh(store->nrecords); store->deltat = fe32toh(store->deltat); if (-1 == fstat(store->f_data, &st)) { return FSTAT_TRACES_FAILED; } if (st.st_size < 0) { return FSTAT_TRACES_FAILED; } store->data_size = (uint64_t)st.st_size; if (store->nrecords >= (UINT64_MAX - GF_STORE_HEADER_SIZE) / sizeof(record_t)) { return BAD_STORE; } mmap_index_size = sizeof(record_t) * store->nrecords + GF_STORE_HEADER_SIZE; if (mmap_index_size >= SIZE_MAX) { return MMAP_INDEX_FAILED; } p = mmap(NULL, mmap_index_size, PROT_READ, MAP_SHARED, store->f_index, 0); if (MAP_FAILED == p) { return MMAP_INDEX_FAILED; } store->records = (record_t*)((char*)p+GF_STORE_HEADER_SIZE); /* on 32-bit systems, use mmap only if traces file is considerably smaller * than address space */ use_mmap = store->data_size < SIZE_MAX / 8; if (use_mmap) { if (store->data_size >= SIZE_MAX) { return MMAP_TRACES_FAILED; } p = mmap(NULL, store->data_size, PROT_READ, MAP_SHARED, store->f_data, 0); if (MAP_FAILED == p) { return MMAP_TRACES_FAILED; } store->data = (gf_dtype*)p; } else { if (store->nrecords > SIZE_MAX) { return ALLOC_FAILED; } store->memdata = (gf_dtype**)calloc(store->nrecords, sizeof(gf_dtype*)); if (NULL == store->memdata) { return ALLOC_FAILED; } } return SUCCESS; }
static store_error_t store_get( const store_t *store, uint64_t irecord, trace_t *trace) { record_t *record; uint64_t data_offset; store_error_t err; size_t nbytes; if (irecord >= store->nrecords) { *trace = ZERO_TRACE; return INVALID_RECORD; } record = &store->records[irecord]; data_offset = xe64toh(record->data_offset); trace->itmin = xe32toh(record->itmin); trace->nsamples = xe32toh(record->nsamples); trace->begin_value = fe32toh(record->begin_value); trace->end_value = fe32toh(record->end_value); if (!inlimits(trace->itmin) || !inposlimits(trace->nsamples) || data_offset >= UINT64_MAX - SLIMIT * sizeof(gf_dtype)) { return BAD_RECORD; } if (REC_EMPTY == data_offset) { *trace = ZERO_TRACE; return EMPTY_RECORD; } if (REC_ZERO == data_offset) { *trace = ZERO_TRACE; trace->itmin = xe32toh(record->itmin); return SUCCESS; } trace->is_zero = 0; if (data_offset + trace->nsamples*sizeof(gf_dtype) > store->data_size) { *trace = ZERO_TRACE; return BAD_DATA_OFFSET; } if (REC_SHORT == data_offset) { trace->data = &record->begin_value; } else { if (NULL != store->data) { trace->data = &store->data[data_offset/sizeof(gf_dtype)]; } else { if (NULL == store->memdata[irecord]) { nbytes = trace->nsamples * sizeof(gf_dtype); store->memdata[irecord] = (gf_dtype*)malloc(nbytes); if (NULL == store->memdata[irecord]) { *trace = ZERO_TRACE; return ALLOC_FAILED; } err = store_read(store, data_offset, nbytes, store->memdata[irecord]); if (SUCCESS != err) { free(store->memdata[irecord]); store->memdata[irecord] = NULL; *trace = ZERO_TRACE; return err; } } trace->data = store->memdata[irecord]; } } return SUCCESS; }
/* * elf to a.out converter for freebsd/sparc64 bootblocks. */ int main(int ac, char **av) { Elf64_Half phentsize; Elf64_Half machine; Elf64_Half phnum; Elf64_Xword filesz; Elf64_Xword memsz; Elf64_Addr entry; Elf64_Off offset; Elf64_Off phoff; Elf64_Word type; unsigned char data; struct stat sb; struct exec a; Elf64_Phdr *p; Elf64_Ehdr *e; void *v; int efd; int fd; int c; int i; fd = STDIN_FILENO; while ((c = getopt(ac, av, "o:")) != -1) switch (c) { case 'o': if ((fd = open(optarg, O_CREAT|O_RDWR, 0644)) < 0) err(1, "%s", optarg); break; case '?': default: usage(); } ac -= optind; av += optind; if (ac == 0) usage(); if ((efd = open(*av, O_RDONLY)) < 0 || fstat(efd, &sb) < 0) err(1, NULL); v = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, efd, 0); if ((e = v) == MAP_FAILED) err(1, NULL); if (!IS_ELF(*e)) errx(1, "not an elf file"); if (e->e_ident[EI_CLASS] != ELFCLASS64) errx(1, "wrong class"); data = e->e_ident[EI_DATA]; if (data != ELFDATA2MSB && data != ELFDATA2LSB) errx(1, "wrong data format"); if (e->e_ident[EI_VERSION] != EV_CURRENT) errx(1, "wrong elf version"); machine = xe16toh(e->e_machine); if (machine != EM_SPARCV9 && machine != EM_ALPHA) errx(1, "wrong machine type"); phentsize = xe16toh(e->e_phentsize); if (phentsize != sizeof(*p)) errx(1, "phdr size mismatch"); entry = xe64toh(e->e_entry); phoff = xe64toh(e->e_phoff); phnum = xe16toh(e->e_phnum); p = (Elf64_Phdr *)((char *)e + phoff); bzero(&a, sizeof(a)); for (i = 0; i < phnum; i++) { type = xe32toh(p[i].p_type); switch (type) { case PT_LOAD: if (a.a_magic != 0) errx(1, "too many loadable segments"); filesz = xe64toh(p[i].p_filesz); memsz = xe64toh(p[i].p_memsz); offset = xe64toh(p[i].p_offset); a.a_magic = htoxe32(A_MAGIC); a.a_text = htoxe32(filesz); a.a_bss = htoxe32(memsz - filesz); a.a_entry = htoxe32(entry); if (write(fd, &a, sizeof(a)) != sizeof(a) || write(fd, (char *)e + offset, filesz) != (ssize_t)filesz) err(1, NULL); break; default: break; } } return (0); }