int main(int argc, char *argv[]) { pa_mempool *pool; pa_sample_spec a, b; pa_cvolume v; pa_log_set_level(PA_LOG_DEBUG); pa_assert_se(pool = pa_mempool_new(FALSE, 0)); a.channels = b.channels = 1; a.rate = b.rate = 44100; v.channels = a.channels; v.values[0] = pa_sw_volume_from_linear(0.5); for (a.format = 0; a.format < PA_SAMPLE_MAX; a.format ++) { for (b.format = 0; b.format < PA_SAMPLE_MAX; b.format ++) { pa_resampler *forth, *back; pa_memchunk i, j, k; printf("=== %s -> %s -> %s -> /2\n", pa_sample_format_to_string(a.format), pa_sample_format_to_string(b.format), pa_sample_format_to_string(a.format)); pa_assert_se(forth = pa_resampler_new(pool, &a, NULL, &b, NULL, PA_RESAMPLER_AUTO, 0)); pa_assert_se(back = pa_resampler_new(pool, &b, NULL, &a, NULL, PA_RESAMPLER_AUTO, 0)); i.memblock = generate_block(pool, &a); i.length = pa_memblock_get_length(i.memblock); i.index = 0; pa_resampler_run(forth, &i, &j); pa_resampler_run(back, &j, &k); printf("before: "); dump_block(&a, &i); printf("after : "); dump_block(&b, &j); printf("reverse: "); dump_block(&a, &k); pa_memblock_unref(j.memblock); pa_memblock_unref(k.memblock); pa_volume_memchunk(&i, &a, &v); printf("volume: "); dump_block(&a, &i); pa_memblock_unref(i.memblock); pa_resampler_free(forth); pa_resampler_free(back); } } pa_mempool_free(pool); return 0; }
void full_dump_partition_entry(partition_map_header *map, int ix) { partition_map * cur; DPME *p; int i; uint32_t t; cur = find_entry_by_disk_address(ix, map); if (cur == NULL) { printf("No such partition\n"); return; } p = cur->data; printf(" signature: 0x%x\n", p->dpme_signature); printf(" reserved1: 0x%x\n", p->dpme_reserved_1); printf(" number of map entries: %"PRId32"\n", p->dpme_map_entries); printf(" physical start: %10"PRIu32" length: %10"PRIu32"\n", p->dpme_pblock_start, p->dpme_pblocks); printf(" logical start: %10"PRIu32" length: %10"PRIu32"\n", p->dpme_lblock_start, p->dpme_lblocks); printf(" flags: 0x%"PRIx32"\n", (uint32_t)p->dpme_flags); printf(" "); if (dpme_valid_get(p)) printf("valid "); if (dpme_allocated_get(p)) printf("alloc "); if (dpme_in_use_get(p)) printf("in-use "); if (dpme_bootable_get(p)) printf("boot "); if (dpme_readable_get(p)) printf("read "); if (dpme_writable_get(p)) printf("write "); if (dpme_os_pic_code_get(p)) printf("pic "); t = p->dpme_flags >> 7; for (i = 7; i <= 31; i++) { if (t & 0x1) { printf("%d ", i); } t = t >> 1; } printf("\n"); printf(" name: '%.32s'\n", p->dpme_name); printf(" type: '%.32s'\n", p->dpme_type); printf(" boot start block: %10"PRIu32"\n", p->dpme_boot_block); printf("boot length (in bytes): %10"PRIu32"\n", p->dpme_boot_bytes); printf(" load address: 0x%08"PRIx32" 0x%08"PRIx32"\n", (uint32_t)p->dpme_load_addr, (uint32_t)p->dpme_load_addr_2); printf(" start address: 0x%08"PRIx32" 0x%08"PRIx32"\n", (uint32_t)p->dpme_goto_addr, (uint32_t)p->dpme_goto_addr_2); printf(" checksum: 0x%08"PRIx32"\n", p->dpme_checksum); printf(" processor: '%.32s'\n", p->dpme_process_id); printf("boot args field -"); dump_block((uint8_t *)p->dpme_boot_args, 32*4); printf("dpme_reserved_3 -"); dump_block((uint8_t *)p->dpme_reserved_3, 62*4); }
void dump_tree (tree_s *tree) { FN; printf("Tree------------------------------------------------\n"); dump_block(tree, root_blkno(tree), 0); fflush(stdout); }
void dump_bplustree(Disk &disk, BPositionIO *file, off_t size, bool hexDump) { uint8 *buffer = (uint8 *)malloc(size); if (buffer == NULL) { puts("no buffer"); return; } if (file->ReadAt(0, buffer, size) != size) { puts("couldn't read whole file"); return; } bplustree_header *header = (bplustree_header *)buffer; int32 nodeSize = header->node_size; dump_bplustree_header(header); bplustree_node *node = (bplustree_node *)(buffer + nodeSize); while ((addr_t)node < (addr_t)buffer + size) { printf("\n\n-------------------\n" "** node at offset: %" B_PRIuADDR "\n** used: %" B_PRId32 " bytes" "\n", (addr_t)node - (addr_t)buffer, node->Used()); dump_bplustree_node(node, header, &disk); if (hexDump) { putchar('\n'); dump_block((char *)node, header->node_size, 0); } node = (bplustree_node *)((addr_t)node + nodeSize); } }
static void dump_buffer(net_buffer *_buffer) { net_buffer_private *buffer = (net_buffer_private *)_buffer; dprintf("buffer %p, size %ld, data: %p\n", buffer, buffer->size, buffer->data); dump_block((char*)buffer->data, min_c(buffer->size, 32), " "); }
static ssize_t r3964_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count) { struct r3964_info *pInfo = tty->disc_data; struct r3964_block_header *pHeader; struct r3964_client_info *pClient; unsigned char *new_data; TRACE_L("write request, %d characters", count); if (!pInfo) return -EIO; if (count > R3964_MTU) { if (pInfo->flags & R3964_DEBUG) { TRACE_L(KERN_WARNING "r3964_write: truncating user " "packet from %u to mtu %d", count, R3964_MTU); } count = R3964_MTU; } new_data = kmalloc(count + sizeof(struct r3964_block_header), GFP_KERNEL); TRACE_M("r3964_write - kmalloc %p", new_data); if (new_data == NULL) { if (pInfo->flags & R3964_DEBUG) { printk(KERN_ERR "r3964_write: no memory\n"); } return -ENOSPC; } pHeader = (struct r3964_block_header *)new_data; pHeader->data = new_data + sizeof(struct r3964_block_header); pHeader->length = count; pHeader->locks = 0; pHeader->owner = NULL; tty_lock(); pClient = findClient(pInfo, task_pid(current)); if (pClient) { pHeader->owner = pClient; } memcpy(pHeader->data, data, count); if (pInfo->flags & R3964_DEBUG) { dump_block(pHeader->data, count); } add_tx_queue(pInfo, pHeader); trigger_transmit(pInfo); tty_unlock(); return 0; }
krb5_boolean krb5int_c_iov_get_block(unsigned char *block, size_t block_size, const krb5_crypto_iov *data, size_t num_data, struct iov_block_state *iov_state) { size_t i, j = 0; for (i = iov_state->iov_pos; i < num_data; i++) { const krb5_crypto_iov *iov = &data[i]; size_t nbytes; if (!process_block_p(data, num_data, iov_state, i)) continue; if (pad_to_boundary_p(data, num_data, iov_state, i, j)) break; iov_state->iov_pos = i; nbytes = iov->data.length - iov_state->data_pos; if (nbytes > block_size - j) nbytes = block_size - j; memcpy(block + j, iov->data.data + iov_state->data_pos, nbytes); iov_state->data_pos += nbytes; j += nbytes; assert(j <= block_size); if (j == block_size) break; assert(iov_state->data_pos == iov->data.length); iov_state->data_pos = 0; } iov_state->iov_pos = i; if (i == num_data) return FALSE; if (j != block_size) memset(block + j, 0, block_size - j); #ifdef DEBUG_IOV dump_block("get_block", i, j, block, block_size); #endif return TRUE; }
void Profiler::dump( bool showUnused, bool showTotal, unsigned maxDepth ) const { const uint8_t color = 0x1f; if (!showTotal) { DBG_TEX_PRINTF(color, "Block Cnt Avg Max Frame Total"); } else { DBG_TEX_PRINTF(color, "Block Last frame Whole execution time"); DBG_TEX_PRINTF(color, " Cnt Avg Max Total Cnt Avg Max Total"); } dump_block(root_, 0, maxDepth, showUnused, showTotal); }
/* * dump_rtn386 - dump a near or far routine defn (386) */ static void dump_rtn386( unsigned_8 *buff ) /*****************************************/ { int pro,epi; unsigned_32 ret_off; unsigned_8 *ptr; int num_parms; unsigned_16 index; char name[256]; int i; dump_block( buff, TRUE ); ptr = buff + sizeof( block_386 ); pro = *ptr++; epi = *ptr++; Wdputs( " prologue size = " ); Putdec( pro ); Wdputs( ", epilogue size = " ); Putdec( epi ); Wdputslc( "\n" ); ret_off = *(unsigned_32 *) ptr; ptr += sizeof( unsigned_32 ); Wdputs( " return address offset (from bp) = " ); Puthex( ret_off, 8 ); Wdputslc( "\n" ); ptr = Get_type_index( ptr, &index ); Wdputs( " return type: " ); Putdec( index ); Wdputslc( "\n" ); Wdputs( " return value: " ); ptr = Dump_location_expression( ptr, " " ); num_parms = *ptr++; for( i = 0; i < num_parms; i++ ) { Wdputs( " Parm " ); Putdec( i ); Wdputs( ": " ); ptr = Dump_location_expression( ptr, " " ); } Get_local_name( name, ptr, buff ); Wdputs( " Name = \"" ); Wdputs( name ); Wdputslc( "\"\n" ); } /* dump_rtn386 */
void dump_branch ( tree_s *tree, branch_s *branch, unint indent) { key_s *k; unsigned i; //FN; if (!branch) return; pr_indent(indent); printf("branch: num keys = %d\n", branch->br_num); pr_indent(indent); printf("first %llx\n", branch->br_first); dump_block(tree, branch->br_first, indent+1); for (k = branch->br_key, i = 0; i < branch->br_num; k++, i++) { pr_indent(indent); printf("%4d. %16llx: %llx\n", i, k->k_key, k->k_block); dump_block(tree, k->k_block, indent+1); } }
/* * Read a Record from the block * Returns: false if nothing read or if the continuation record does not match. * In both of these cases, a block read must be done. * true if at least the record header was read, this * routine may have to be called again with a new * block if the entire record was not read. */ bool read_record_from_block(DCR *dcr, DEV_RECORD *rec) { bool rtn; Dmsg0(dbgep, "=== rpath 1 Enter read_record_from block\n"); for ( ;; ) { switch (rec->rstate) { case st_none: dump_block(dcr->block, "st_none"); case st_header: Dmsg0(dbgep, "=== rpath 33 st_header\n"); rec->remlen = dcr->block->binbuf; /* Note read_header sets rec->rstate on return true */ if (!read_header(dcr, dcr->block, rec)) { /* sets state */ Dmsg0(dbgep, "=== rpath 34 failed read header\n"); Dmsg0(read_dbglvl, "read_header returned EOF.\n"); goto fail_out; } continue; case st_data: Dmsg0(dbgep, "=== rpath 37 st_data\n"); read_data(dcr->block, rec); rec->rstate = st_header; /* next pass look for a header */ goto get_out; default: Dmsg0(dbgep, "=== rpath 50 default\n"); Dmsg0(0, "======= In default !!!!!\n"); Pmsg1(190, "Read: unknown state=%d\n", rec->rstate); goto fail_out; } } get_out: char buf1[100], buf2[100]; Dmsg5(read_dbglvl, "read_rec return: FI=%s Strm=%s len=%d rem=%d remainder=%d\n", FI_to_ascii(buf1, rec->FileIndex), stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len, rec->remlen, rec->remainder); rtn = true; goto out; fail_out: rec->rstate = st_none; rtn = false; out: return rtn; }
void dump_blocks(const map<gough_edge_id, vector<gough_ins> > &blocks, const string &base, const Grey &grey) { if (!grey.dumpFlags) { return; } FILE *f; { stringstream ss; ss << grey.dumpPath << "gough_" << base << "_programs.txt"; f = fopen(ss.str().c_str(), "w"); } for (const auto &m : blocks) { dump_block(f, m.first, m.second); } fclose(f); }
void full_dump_block_zero(partition_map_header *map) { Block0 *zp; DDMap *m; int i; if (map == NULL) { printf("No partition map exists\n"); return; } if (map->misc == NULL) { printf("No block zero\n"); return; } zp = map->misc; printf(" signature: 0x%x\n", zp->sbSig); printf(" size of a block: %d\n", zp->sbBlkSize); printf(" number of blocks: %"PRId32"\n", zp->sbBlkCount); printf(" device type: 0x%x\n", zp->sbDevType); printf(" device id: 0x%x\n", zp->sbDevId); printf(" data: 0x%"PRIx32"\n", zp->sbData); printf(" driver count: %d\n", zp->sbDrvrCount); m = (DDMap *) zp->sbMap; for (i = 0; &m[i].ddType < &zp->sbMap[247]; i++) { if (m[i].ddBlock == 0 && m[i].ddSize == 0 && m[i].ddType == 0) { break; } printf(" driver %3u block: %"PRId32"\n", i+1, m[i].ddBlock); printf(" size in blocks: %d\n", m[i].ddSize); printf(" driver type: 0x%x\n", m[i].ddType); } printf("remainder of block -"); dump_block((uint8_t *)(void *)&m[i].ddBlock, (&zp->sbMap[247]-((uint16_t *)(void *)&m[i].ddBlock))*2); }
int test_malloc( ) { char *a, *b, *c, *d, *e, *f; printf( "arena @ %d\n", arena ); // printf("arenaned @ %d\n", arenaend); printf( "pages = %d\n", _arena_pages ); a = ( char * ) malloc( 700 ); dump_mheader( arena ); printf( "a @ %08X\n", a ); dump_block( a ); b = ( char * ) malloc( 70000 ); printf( "b @ %08X\n", b ); dump_block( b ); printf( "\n" ); free( a ); dump_mheader( arena ); dump_block( b ); c = ( char * ) malloc( 100 ); printf( "c @ %08X\n", c ); dump_block( c ); printf( "\n" ); dump_mheader( arena ); c = ( char * ) realloc( c, 3 ); printf( "c @ %08X\n", c ); dump_block( c ); c = ( char * ) realloc( c, 3000 ); printf( "c @ %08X\n", c ); dump_block( c ); return 1; }
int main(int argc, char *argv[]) { errcode_t ret; int c; int64_t blkno, count, blksize; char *filename; io_channel *channel; char *blks; /* Some simple defaults */ blksize = 512; blkno = 0; count = 1; initialize_ocfs_error_table(); while((c = getopt(argc, argv, "b:c:B:")) != EOF) { switch (c) { case 'b': blkno = read_number(optarg); if (blkno < 0) { fprintf(stderr, "Invalid blkno: %s\n", optarg); print_usage(); return 1; } break; case 'c': count = read_number(optarg); if (!count) { fprintf(stderr, "Invalid count: %s\n", optarg); print_usage(); return 1; } break; case 'B': blksize = read_number(optarg); if (!blksize) { fprintf(stderr, "Invalid blksize: %s\n", optarg); print_usage(); return 1; } break; default: print_usage(); return 1; break; } } if (blksize % OCFS2_MIN_BLOCKSIZE) { fprintf(stderr, "Invalid blocksize: %"PRId64"\n", blksize); print_usage(); return 1; } if (count < 0) { if (-count > (int64_t)INT_MAX) { fprintf(stderr, "Count is too large: %"PRId64"\n", count); print_usage(); return 1; } count = -count / blksize; } else { if ((count * blksize) > INT_MAX) { fprintf(stderr, "Count is too large: %"PRId64"\n", count); print_usage(); return 1; } } if (optind >= argc) { fprintf(stderr, "Missing filename\n"); print_usage(); return 1; } filename = argv[optind]; ret = io_open(filename, OCFS2_FLAG_RO, &channel); if (ret) { com_err(argv[0], ret, "while opening file \"%s\"", filename); goto out; } ret = ocfs2_malloc_blocks(channel, (int)count, &blks); if (ret) { com_err(argv[0], ret, "while allocating %"PRId64" blocks", count); goto out_channel; } ret = io_read_block(channel, blkno, (int)count, blks); if (ret) { com_err(argv[0], ret, "while reading %"PRId64" blocks at block %"PRId64" (%s)", count, blkno, strerror(io_get_error(channel))); goto out_blocks; } for (c = 0; c < count; c++) dump_block(blkno + c, blksize, blks + (c * blksize)); out_blocks: ocfs2_free(&blks); out_channel: ret = io_close(channel); if (ret) { com_err(argv[0], ret, "while closing file \"%s\"", filename); } out: return 0; }
void do_display_block(partition_map_header *map, char *alt_name) { MEDIA m; long number; char *name; static unsigned char *display_block; static int display_g; int g; static long next_number = -1; if (map != NULL) { name = 0; m = map->m; g = map->logical_block; } else { if (alt_name == 0) { if (get_string_argument("Name of device: ", &name, 1) == 0) { bad_input("Bad name"); return; } } else { name = strdup(alt_name); } m = open_pathname_as_media(name, O_RDONLY); if (m == 0) { error(errno, "can't open file '%s'", name); free(name); return; } g = media_granularity(m); if (g < PBLOCK_SIZE) { g = PBLOCK_SIZE; } } if (get_number_argument("Block number: ", &number, next_number) == 0) { bad_input("Bad block number"); goto xit; } if (display_block == NULL || display_g < g) { if (display_block != NULL) { free(display_block); display_g = 0; } display_block = (unsigned char *) malloc(g); if (display_block == NULL) { error(errno, "can't allocate memory for display block buffer"); goto xit; } display_g = g; } if (read_media(m, ((long long)number) * g, g, (char *)display_block) != 0) { printf("block %ld -", number); dump_block((unsigned char*) display_block, g); next_number = number + 1; } xit: if (name) { close_media(m); free(name); } return; }
void Profiler::dump_block( ProfilerBlock* block, unsigned depth, unsigned maxDepth, bool showUnused, bool showTotal ) const { char indentedName[LINE_MAX_LENGTH]; unsigned intervalFrames = max(intervalFrames_, 1); const uint8_t color = 0x8f; if (depth >= maxDepth) return; // Do not print the root block as it does not collect any actual data if (block != root_) { if (showUnused || block->intervalCount_ || (showTotal && block->totalCount_)) { memset(indentedName, ' ', NAME_MAX_LENGTH); indentedName[depth] = 0; strcat(indentedName, block->name_); indentedName[strlen(indentedName)] = ' '; indentedName[NAME_MAX_LENGTH] = 0; if (!showTotal) { float avg = (block->intervalCount_ ? block->intervalTime_ / block->intervalCount_ : 0.0f) / 1000.0f; float max = block->intervalMaxTime_ / 1000.0f; float frame = block->intervalTime_ / intervalFrames / 1000.0f; float all = block->intervalTime_ / 1000.0f; DBG_TEX_PRINTF( color, "%s %5u %8.3f %8.3f %8.3f %9.3f", indentedName, min(block->intervalCount_, 99999), avg, max, frame, all); } else { float avg = (block->frameCount_ ? block->frameTime_ / block->frameCount_ : 0.0f) / 1000.0f; float max = block->frameMaxTime_ / 1000.0f; float all = block->frameTime_ / 1000.0f; float totalAvg = (block->totalCount_ ? block->totalTime_ / block->totalCount_ : 0.0f) / 1000.0f; float totalMax = block->totalMaxTime_ / 1000.0f; float totalAll = block->totalTime_ / 1000.0f; DBG_TEX_PRINTF( color, "%s %5u %8.3f %8.3f %9.3f %7u %9.3f %9.3f %11.3f", indentedName, min(block->frameCount_, 99999), avg, max, all, min(block->totalCount_, 99999), totalAvg, totalMax, totalAll); } } ++depth; } uint32_t num = block->numChildren_; for (uint32_t i=0; i<num; ++i) { dump_block(block->children_[i], depth, maxDepth, showUnused, showTotal); } }
void dump_blocks (RList* list) { RListIter *iter; bb_t *block = NULL; r_list_foreach (list, iter, block) { dump_block(block); }
void display_patches(partition_map *entry) { long long offset; MEDIA m; static uint8_t *patch_block; PatchListPtr p; PatchDescriptorPtr q; uint8_t *next; uint8_t *s; int i; offset = entry->data->dpme_pblock_start; m = entry->the_map->m; offset = ((long long) entry->data->dpme_pblock_start) * entry->the_map->logical_block; if (patch_block == NULL) { patch_block = (uint8_t *) malloc(PBLOCK_SIZE); if (patch_block == NULL) { error(errno, "can't allocate memory for patch block buffer"); return; } } if (read_media(m, (long long)offset, PBLOCK_SIZE, (char *)patch_block) == 0) { error(errno, "Can't read patch block"); return; } p = (PatchListPtr) patch_block; if (p->numPatchBlocks != 1) { i = p->numPatchBlocks; free(patch_block); patch_block = (uint8_t *) malloc(PBLOCK_SIZE*i); if (patch_block == NULL) { error(errno, "can't allocate memory for patch blocks buffer"); return; } s = patch_block + PBLOCK_SIZE*i; while (i > 0) { s -= PBLOCK_SIZE; i -= 1; if (read_media(m, offset+i, PBLOCK_SIZE, (char *)s) == 0) { error(errno, "Can't read patch block %d", i); return; } } p = (PatchListPtr) patch_block; } printf("Patch list (%d entries)\n", p->numPatches); q = p->thePatch; for (i = 0; i < p->numPatches; i++) { printf("%2d signature: '%.4s'\n", i+1, (char *)&q->patchSig); printf(" version: %d.%d\n", q->majorVers, q->minorVers); printf(" flags: 0x%"PRIx32"\n", q->flags); printf(" offset: %"PRId32"\n", q->patchOffset); printf(" size: %"PRId32"\n", q->patchSize); printf(" CRC: 0x%"PRIx32"\n", q->patchCRC); printf(" name: '%.*s'\n", q->patchName[0], &q->patchName[1]); printf(" vendor: '%.*s'\n", q->patchVendor[0], &q->patchVendor[1]); next = ((uint8_t *)q) + q->patchDescriptorLen; s = &q->patchVendor[q->patchVendor[0]+1]; if (next > s) { printf("remainder of entry -"); dump_block(s, next-s); } q = (PatchDescriptorPtr)next; } }
int main( int argc, char *argv[] ) { extern char *optarg; int ch; int formatdisk = 0; int dumpblock = 0; int examinedisk = 0; int track = -1; int sector = -1; char *binary = NULL; char *disk = NULL; FILE *disk_fp; char *open_mode; disk = argv[1]; while( (ch = getopt(argc-1, &argv[1], "vdfdxb:t:s:")) != -1 ) switch(ch) { case 'v': { verbose = 1; break; } case 'f': { formatdisk = 1; break; } case 'd': { dumpblock = 1; break; } case 'x': { examinedisk = 1; break; } case 'b': { binary = optarg; break; } case 't': { track = atoi(optarg); break; } case 's': { sector = atoi(optarg); break; } case '?': case 'h': default: usage(); } if( disk == NULL ) { fprintf( stderr, "error: no disk image specified\n" ); exit(1); } if( formatdisk ) open_mode="w+"; else open_mode="r+"; if( (disk_fp = fopen(disk, open_mode)) == NULL ) { perror( disk ); exit(1); } if( formatdisk ) format_disk( &disk_fp ); if( binary != NULL ) { sanity_check( track, sector ); insert_binary( &disk_fp, binary, track, sector ); } if( dumpblock ) { sanity_check( track, sector ); dump_block( &disk_fp, track, sector ); } fclose( disk_fp ); return 0; }
static void print_one_frame_reg_col(Dwarf_Debug dbg, Dwarf_Unsigned rule_id, Dwarf_Small value_type, Dwarf_Unsigned reg_used, struct dwconf_s *config_data, Dwarf_Signed offset_relevant, Dwarf_Signed offset, Dwarf_Ptr block_ptr) { char *type_title = ""; int print_type_title = 1; if (config_data->cf_interface_number == 2) print_type_title = 0; switch (value_type) { case DW_EXPR_OFFSET: type_title = "off"; goto preg2; case DW_EXPR_VAL_OFFSET: type_title = "valoff"; preg2: if (reg_used == config_data->cf_initial_rule_value) { break; } if (print_type_title) printf("<%s ", type_title); printreg((Dwarf_Signed) rule_id, config_data); printf("="); if (offset_relevant == 0) { printreg((Dwarf_Signed) reg_used, config_data); printf(" "); } else { printf("%02lld", offset); printf("("); printreg((Dwarf_Signed) reg_used, config_data); printf(") "); } if (print_type_title) printf("%s", "> "); break; case DW_EXPR_EXPRESSION: type_title = "expr"; goto pexp2; case DW_EXPR_VAL_EXPRESSION: type_title = "valexpr"; pexp2: if (print_type_title) printf("<%s ", type_title); printreg((Dwarf_Signed) rule_id, config_data); printf("="); printf("expr-block-len=%lld", (long long) offset); if (print_type_title) printf("%s", "> "); if (verbose) { char pref[40]; strcpy(pref, "<"); strcat(pref, type_title); strcat(pref, "bytes:"); dump_block(pref, block_ptr, offset); printf("%s", "> "); if(verbose) { struct esb_s exprstring; esb_constructor(&exprstring); get_string_from_locs(dbg, block_ptr,offset,&exprstring); printf("<expr:%s>",esb_get_string(&exprstring)); esb_destructor(&exprstring); } } break; default: printf("Internal error in libdwarf, value type %d\n", value_type); exit(1); } return; }
/*ARGSUSED*/ void print_frame_inst_bytes(Dwarf_Debug dbg, Dwarf_Ptr cie_init_inst, Dwarf_Signed len, Dwarf_Signed data_alignment_factor, int code_alignment_factor, Dwarf_Half addr_size, struct dwconf_s *config_data) { unsigned char *instp = (unsigned char *) cie_init_inst; Dwarf_Unsigned uval; Dwarf_Unsigned uval2; unsigned int uleblen; unsigned int off = 0; unsigned int loff = 0; unsigned short u16; unsigned int u32; unsigned long long u64; for (; len > 0;) { unsigned char ibyte = *instp; int top = ibyte & 0xc0; int bottom = ibyte & 0x3f; int delta; int reg; switch (top) { case DW_CFA_advance_loc: delta = ibyte & 0x3f; printf("\t%2u DW_CFA_advance_loc %d", off, (int) (delta * code_alignment_factor)); if (verbose) { printf(" (%d * %d)", (int) delta, (int) code_alignment_factor); } printf("\n"); break; case DW_CFA_offset: loff = off; reg = ibyte & 0x3f; uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_offset ", loff); printreg((Dwarf_Signed) reg, config_data); printf(" %lld", (signed long long) (((Dwarf_Signed) uval) * data_alignment_factor)); if (verbose) { printf(" (%llu * %d)", (unsigned long long) uval, (int) data_alignment_factor); } printf("\n"); break; case DW_CFA_restore: reg = ibyte & 0x3f; printf("\t%2u DW_CFA_restore \n", off); printreg((Dwarf_Signed) reg, config_data); printf("\n"); break; default: loff = off; switch (bottom) { case DW_CFA_set_loc: /* operand is address, so need address size */ /* which will be 4 or 8. */ switch (addr_size) { case 4: { __uint32_t v32; memcpy(&v32, instp + 1, addr_size); uval = v32; } break; case 8: { __uint64_t v64; memcpy(&v64, instp + 1, addr_size); uval = v64; } break; default: printf ("Error: Unexpected address size %d in DW_CFA_set_loc!\n", addr_size); uval = 0; } instp += addr_size; len -= (Dwarf_Signed) addr_size; off += addr_size; printf("\t%2u DW_CFA_set_loc %llu\n", loff, (unsigned long long) uval); break; case DW_CFA_advance_loc1: delta = (unsigned char) *(instp + 1); uval2 = delta; instp += 1; len -= 1; off += 1; printf("\t%2u DW_CFA_advance_loc1 %llu\n", loff, (unsigned long long) uval2); break; case DW_CFA_advance_loc2: memcpy(&u16, instp + 1, 2); uval2 = u16; instp += 2; len -= 2; off += 2; printf("\t%2u DW_CFA_advance_loc2 %llu\n", loff, (unsigned long long) uval2); break; case DW_CFA_advance_loc4: memcpy(&u32, instp + 1, 4); uval2 = u32; instp += 4; len -= 4; off += 4; printf("\t%2u DW_CFA_advance_loc4 %llu\n", loff, (unsigned long long) uval2); break; case DW_CFA_MIPS_advance_loc8: memcpy(&u64, instp + 1, 8); uval2 = u64; instp += 8; len -= 8; off += 8; printf("\t%2u DW_CFA_MIPS_advance_loc8 %llu\n", loff, (unsigned long long) uval2); break; case DW_CFA_offset_extended: uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; uval2 = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_offset_extended ", loff); printreg((Dwarf_Signed) uval, config_data); printf(" %lld", (signed long long) (((Dwarf_Signed) uval2) * data_alignment_factor)); if (verbose) { printf(" (%llu * %d)", (unsigned long long) uval2, (int) data_alignment_factor); } printf("\n"); break; case DW_CFA_restore_extended: uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_restore_extended ", loff); printreg((Dwarf_Signed) uval, config_data); printf("\n"); break; case DW_CFA_undefined: uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_undefined ", loff); printreg((Dwarf_Signed) uval, config_data); printf("\n"); break; case DW_CFA_same_value: uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_same_value ", loff); printreg((Dwarf_Signed) uval, config_data); printf("\n"); break; case DW_CFA_register: uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; uval2 = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_register ", loff); printreg((Dwarf_Signed) uval, config_data); printf(" = "); printreg((Dwarf_Signed) uval2, config_data); printf("\n"); break; case DW_CFA_remember_state: printf("\t%2u DW_CFA_remember_state\n", loff); break; case DW_CFA_restore_state: printf("\t%2u DW_CFA_restore_state\n", loff); break; case DW_CFA_def_cfa: uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; uval2 = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_def_cfa ", loff); printreg((Dwarf_Signed) uval, config_data); printf(" %llu", (unsigned long long) uval2); printf("\n"); break; case DW_CFA_def_cfa_register: uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_def_cfa_register ", loff); printreg((Dwarf_Signed) uval, config_data); printf("\n"); break; case DW_CFA_def_cfa_offset: uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_def_cfa_offset %llu\n", loff, (unsigned long long) uval); break; case DW_CFA_nop: printf("\t%2u DW_CFA_nop\n", loff); break; case DW_CFA_def_cfa_expression: /* DWARF3 */ { Dwarf_Unsigned block_len = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf ("\t%2u DW_CFA_def_cfa_expression expr block len %lld\n", loff, (unsigned long long) block_len); dump_block("\t\t", (char *) instp+1, (Dwarf_Signed) block_len); printf("\n"); if(verbose) { struct esb_s exprstring; esb_constructor(&exprstring); get_string_from_locs(dbg, instp+1,block_len,&exprstring); printf("\t\t%s\n",esb_get_string(&exprstring)); esb_destructor(&exprstring); } instp += block_len; len -= block_len; off += block_len; } break; case DW_CFA_expression: /* DWARF3 */ uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; { /* instp is always 1 byte back, so we need +1 when we use it. See the final increment of this for loop. */ Dwarf_Unsigned block_len = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf ("\t%2u DW_CFA_expression %llu expr block len %lld\n", loff, (unsigned long long) uval, (unsigned long long) block_len); dump_block("\t\t", (char *) instp+1, (Dwarf_Signed) block_len); printf("\n"); if(verbose) { struct esb_s exprstring; esb_constructor(&exprstring); get_string_from_locs(dbg, instp+1,block_len,&exprstring); printf("\t\t%s\n",esb_get_string(&exprstring)); esb_destructor(&exprstring); } instp += block_len; len -= block_len; off += block_len; } break; case DW_CFA_cfa_offset_extended_sf: /* DWARF3 */ uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; { /* instp is always 1 byte back, so we need +1 when we use it. See the final increment of this for loop. */ Dwarf_Signed sval2 = local_dwarf_decode_s_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_offset_extended_sf ", loff); printreg((Dwarf_Signed) uval, config_data); printf(" %lld", (signed long long) ((sval2) * data_alignment_factor)); if (verbose) { printf(" (%lld * %d)", (long long) sval2, (int) data_alignment_factor); } } printf("\n"); break; case DW_CFA_def_cfa_sf: /* DWARF3 */ /* instp is always 1 byte back, so we need +1 when we use it. See the final increment of this for loop. */ uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; { Dwarf_Signed sval2 = local_dwarf_decode_s_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_def_cfa_sf ", loff); printreg((Dwarf_Signed) uval, config_data); printf(" %lld", (long long) sval2); printf(" (*data alignment factor=>%lld)", (long long)(sval2*data_alignment_factor)); } printf("\n"); break; case DW_CFA_def_cfa_offset_sf: /* DWARF3 */ { /* instp is always 1 byte back, so we need +1 when we use it. See the final increment of this for loop. */ Dwarf_Signed sval = local_dwarf_decode_s_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_def_cfa_offset_sf %lld (*data alignment factor=> %lld)\n", loff, (long long) sval, (long long)(data_alignment_factor*sval)); } break; case DW_CFA_val_offset: /* DWARF3 */ /* instp is always 1 byte back, so we need +1 when we use it. See the final increment of this for loop. */ uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; { uval2 = local_dwarf_decode_s_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_val_offset ", loff); printreg((Dwarf_Signed) uval, config_data); printf(" %lld", (unsigned long long) (((Dwarf_Signed) uval2) * data_alignment_factor)); if (verbose) { printf(" (%lld * %d)", (long long) uval2, (int) data_alignment_factor); } } printf("\n"); break; case DW_CFA_val_offset_sf: /* DWARF3 */ /* instp is always 1 byte back, so we need +1 when we use it. See the final increment of this for loop. */ uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; { Dwarf_Signed sval2 = local_dwarf_decode_s_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf("\t%2u DW_CFA_val_offset_sf ", loff); printreg((Dwarf_Signed) uval, config_data); printf(" %lld", (signed long long) ((sval2) * data_alignment_factor)); if (verbose) { printf(" (%lld * %d)", (long long) sval2, (int) data_alignment_factor); } } printf("\n"); break; case DW_CFA_val_expression: /* DWARF3 */ /* instp is always 1 byte back, so we need +1 when we use it. See the final increment of this for loop. */ uval = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; { Dwarf_Unsigned block_len = local_dwarf_decode_u_leb128(instp + 1, &uleblen); instp += uleblen; len -= uleblen; off += uleblen; printf ("\t%2u DW_CFA_val_expression %llu expr block len %lld\n", loff, (unsigned long long) uval, (unsigned long long) block_len); dump_block("\t\t", (char *) instp+1, (Dwarf_Signed) block_len); printf("\n"); if(verbose) { struct esb_s exprstring; esb_constructor(&exprstring); get_string_from_locs(dbg, instp+1,block_len,&exprstring); printf("\t\t%s\n",esb_get_string(&exprstring)); esb_destructor(&exprstring); } instp += block_len; len -= block_len; off += block_len; } break; #ifdef DW_CFA_GNU_window_save case DW_CFA_GNU_window_save:{ /* no information: this just tells unwinder to restore the window registers from the previous frame's window save area */ printf("\t%2u DW_CFA_GNU_window_save \n", loff); break; } #endif #ifdef DW_CFA_GNU_negative_offset_extended case DW_CFA_GNU_negative_offset_extended:{ printf ("\t%2u DW_CFA_GNU_negative_offset_extended \n", loff); } #endif #ifdef DW_CFA_GNU_args_size /* single uleb128 is the current arg area size in bytes. no register exists yet to save this in */ case DW_CFA_GNU_args_size:{ Dwarf_Unsigned lreg; /* instp is always 1 byte back, so we need +1 when we use it. See the final increment of this for loop. */ lreg = local_dwarf_decode_u_leb128(instp + 1, &uleblen); printf ("\t%2u DW_CFA_GNU_args_size arg size: %llu\n", loff, (unsigned long long) lreg); instp += uleblen; len -= uleblen; off += uleblen; break; } #endif default: printf("\t%u Unexpected op 0x%x: \n", loff, (unsigned int) bottom); len = 0; break; } } instp++; len--; off++; } }
/* * dump_locals - dump all local variable information */ static void dump_locals( mod_info *mi ) /*************************************/ { int i; unsigned_32 *offs; int cnt; unsigned_32 coff; unsigned_8 buff[256]; char name[256]; set_base *sb; set_base386 *sb386; unsigned_8 *ptr; addr32_ptr *p32; addr48_ptr *p48; unsigned_16 index; cnt = mi->di[DMND_LOCALS].u.entries; if( cnt == 0 ) { return; } Wdputslc( "\n" ); Wdputslc( " *** Locals ***\n" ); Wdputslc( " ==============\n" ); offs = alloca( (cnt+1) * sizeof( unsigned_32 ) ); if( offs == NULL ) { Wdputslc( "Error! Not enough stack.\n" ); longjmp( Se_env, 1 ); } Wlseek( Curr_sectoff + mi->di[DMND_LOCALS].info_off ); Wread( offs, (cnt+1) * sizeof( unsigned_32 ) ); for( i = 0; i < cnt; i++ ) { coff = 0; Wdputs( " Data " ); Putdec( i ); Wdputs( ": offset " ); Puthex( offs[i], 8 ); Wdputslc( "\n" ); for( ;; ) { Wlseek( coff + Curr_sectoff + offs[i] ); Wread( buff, sizeof( buff ) ); Wdputs( " " ); Puthex( coff, 4 ); Wdputs( ": " ); switch( buff[1] ) { case MODULE: Wdputslc( "MODULE\n" ); ptr = buff+2; p32 = (addr32_ptr *)ptr; ptr += sizeof( addr32_ptr ); ptr = Get_type_index( ptr, &index ); Get_local_name( name, ptr, buff ); Wdputs( " \"" ); Wdputs( name ); Wdputs( "\" addr = " ); Puthex( p32->segment, 4 ); Wdputc( ':' ); Puthex( p32->offset, 4 ); Wdputs( ", type = " ); Putdec( index ); Wdputslc( "\n" ); break; case LOCAL: Wdputslc( "LOCAL\n" ); ptr = buff+2; Wdputs( " address: " ); ptr = Dump_location_expression( ptr, " " ); ptr = Get_type_index( ptr, &index ); Get_local_name( name, ptr, buff ); Wdputs( " name = \"" ); Wdputs( name ); Wdputs( "\", type = " ); Putdec( index ); Wdputslc( "\n" ); break; case MODULE_386: Wdputslc( "MODULE_386\n" ); ptr = buff+2; p48 = (addr48_ptr *)ptr; ptr += sizeof( addr48_ptr ); ptr = Get_type_index( ptr, &index ); Get_local_name( name, ptr, buff ); Wdputs( " \"" ); Wdputs( name ); Wdputs( "\" addr = " ); Puthex( p48->segment, 4 ); Wdputc( ':' ); Puthex( p48->offset, 8 ); Wdputs( ", type = " ); Putdec( index ); Wdputslc( "\n" ); break; case MODULE_LOC: Wdputslc( "MODULE_LOC\n" ); ptr = buff+2; Wdputs( " address: " ); ptr = Dump_location_expression( ptr, " " ); ptr = Get_type_index( ptr, &index ); Get_local_name( name, ptr, buff ); Wdputs( " name = \"" ); Wdputs( name ); Wdputs( "\", type = " ); Putdec( index ); Wdputslc( "\n" ); break; case BLOCK: Wdputslc( "BLOCK\n" ); dump_block( buff, FALSE ); break; case NEAR_RTN: Wdputslc( "NEAR_RTN\n" ); dump_rtn( buff ); break; case FAR_RTN: Wdputslc( "FAR_RTN\n" ); dump_rtn( buff ); break; case BLOCK_386: Wdputslc( "BLOCK_386\n" ); dump_block( buff, TRUE ); break; case NEAR_RTN_386: Wdputslc( "NEAR_RTN_386\n" ); dump_rtn386( buff ); break; case FAR_RTN_386: Wdputslc( "FAR_RTN_386\n" ); dump_rtn386( buff ); break; case MEMBER_SCOPE: Wdputslc( "MEMBER_SCOPE\n" ); index = 5; ptr = buff+2; Wdputs( " parent offset = " ); Puthex( *ptr, 4 ); ptr += 2; if( *ptr & 0x80 ) { index = 6; } Wdputs( " class type = " ); ptr = Get_type_index( ptr, &index ); Putdec( index ); if( buff[0] > index ) { Wdputslc( "\n object ptr type = " ); Puthex( *ptr++, 2 ); Wdputs( " object loc = " ); Dump_location_expression( ptr, " " ); } Wdputslc( "\n" ); break; case ADD_PREV_SEG: Wdputslc( "ADD_PREV_SEG\n" ); Wdputs( " segment increment = " ); Puthex( *(buff+2), 4 ); Wdputslc( "\n" ); break; case SET_BASE: Wdputslc( "SET_BASE\n" ); sb = (set_base *) buff; Wdputs( " base = " ); Puthex( sb->seg, 4 ); Wdputc( ':' ); Puthex( sb->off, 4 ); Wdputslc( "\n" ); break; case SET_BASE_386: Wdputslc( "SET_BASE_386\n" ); sb386 = (set_base386 *) buff; Wdputs( " base = " ); Puthex( sb386->seg, 4 ); Wdputc( ':' ); Puthex( sb386->off, 8 ); Wdputslc( "\n" ); break; } coff += buff[0]; if( coff >= (offs[i+1] - offs[i]) ) { break; } } } } /* dump_locals */
/* List just block information */ static void do_blocks(char *infname) { DEV_BLOCK *block = dcr->block; char buf1[100], buf2[100]; for ( ;; ) { if (!dcr->read_block_from_device(NO_BLOCK_NUMBER_CHECK)) { Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror()); if (dev->at_eot()) { if (!mount_next_read_volume(dcr)) { Jmsg(jcr, M_INFO, 0, _("Got EOM at file %u on device %s, Volume \"%s\"\n"), dev->file, dev->print_name(), dcr->VolumeName); break; } /* Read and discard Volume label */ DEV_RECORD *record; record = new_record(); dcr->read_block_from_device(NO_BLOCK_NUMBER_CHECK); read_record_from_block(dcr, record); get_session_record(dev, record, &sessrec); free_record(record); Jmsg(jcr, M_INFO, 0, _("Mounted Volume \"%s\".\n"), dcr->VolumeName); } else if (dev->at_eof()) { Jmsg(jcr, M_INFO, 0, _("End of file %u on device %s, Volume \"%s\"\n"), dev->file, dev->print_name(), dcr->VolumeName); Dmsg0(20, "read_record got eof. try again\n"); continue; } else if (dev->is_short_block()) { Jmsg(jcr, M_INFO, 0, "%s", dev->errmsg); continue; } else { /* I/O error */ display_tape_error_status(jcr, dev); break; } } if (!match_bsr_block(bsr, block)) { Dmsg5(100, "reject Blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n", block->BlockNumber, block->block_len, block->BlockVer, block->VolSessionId, block->VolSessionTime); continue; } Dmsg5(100, "Blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n", block->BlockNumber, block->block_len, block->BlockVer, block->VolSessionId, block->VolSessionTime); if (verbose == 1) { read_record_from_block(dcr, rec); Pmsg9(-1, _("File:blk=%u:%u blk_num=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"), dev->file, dev->block_num, block->BlockNumber, block->block_len, FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime, stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len); rec->remainder = 0; } else if (verbose > 1) { dump_block(block, ""); } else { printf(_("Block: %d size=%d\n"), block->BlockNumber, block->block_len); } } return; }
int main(int argc, char *argv[]) { pa_mempool *pool = NULL; pa_sample_spec a, b; int ret = 1, c; bool all_formats = true; pa_resample_method_t method; int seconds; unsigned crossover_freq = 120; static const struct option long_options[] = { {"help", 0, NULL, 'h'}, {"verbose", 0, NULL, 'v'}, {"version", 0, NULL, ARG_VERSION}, {"from-rate", 1, NULL, ARG_FROM_SAMPLERATE}, {"from-format", 1, NULL, ARG_FROM_SAMPLEFORMAT}, {"from-channels", 1, NULL, ARG_FROM_CHANNELS}, {"to-rate", 1, NULL, ARG_TO_SAMPLERATE}, {"to-format", 1, NULL, ARG_TO_SAMPLEFORMAT}, {"to-channels", 1, NULL, ARG_TO_CHANNELS}, {"seconds", 1, NULL, ARG_SECONDS}, {"resample-method", 1, NULL, ARG_RESAMPLE_METHOD}, {"dump-resample-methods", 0, NULL, ARG_DUMP_RESAMPLE_METHODS}, {NULL, 0, NULL, 0} }; setlocale(LC_ALL, ""); #ifdef ENABLE_NLS bindtextdomain(GETTEXT_PACKAGE, PULSE_LOCALEDIR); #endif pa_log_set_level(PA_LOG_WARN); if (!getenv("MAKE_CHECK")) pa_log_set_level(PA_LOG_INFO); pa_assert_se(pool = pa_mempool_new(false, 0)); a.channels = b.channels = 1; a.rate = b.rate = 44100; a.format = b.format = PA_SAMPLE_S16LE; method = PA_RESAMPLER_AUTO; seconds = 60; while ((c = getopt_long(argc, argv, "hv", long_options, NULL)) != -1) { switch (c) { case 'h' : help(argv[0]); ret = 0; goto quit; case 'v': pa_log_set_level(PA_LOG_DEBUG); break; case ARG_VERSION: printf(_("%s %s\n"), argv[0], PACKAGE_VERSION); ret = 0; goto quit; case ARG_DUMP_RESAMPLE_METHODS: dump_resample_methods(); ret = 0; goto quit; case ARG_FROM_CHANNELS: a.channels = (uint8_t) atoi(optarg); break; case ARG_FROM_SAMPLEFORMAT: a.format = pa_parse_sample_format(optarg); all_formats = false; break; case ARG_FROM_SAMPLERATE: a.rate = (uint32_t) atoi(optarg); break; case ARG_TO_CHANNELS: b.channels = (uint8_t) atoi(optarg); break; case ARG_TO_SAMPLEFORMAT: b.format = pa_parse_sample_format(optarg); all_formats = false; break; case ARG_TO_SAMPLERATE: b.rate = (uint32_t) atoi(optarg); break; case ARG_SECONDS: seconds = atoi(optarg); break; case ARG_RESAMPLE_METHOD: if (*optarg == '\0' || pa_streq(optarg, "help")) { dump_resample_methods(); ret = 0; goto quit; } method = pa_parse_resample_method(optarg); break; default: goto quit; } } ret = 0; pa_assert_se(pool = pa_mempool_new(false, 0)); if (!all_formats) { pa_resampler *resampler; pa_memchunk i, j; pa_usec_t ts; pa_log_debug("Compilation CFLAGS: %s", PA_CFLAGS); pa_log_debug("=== %d seconds: %d Hz %d ch (%s) -> %d Hz %d ch (%s)", seconds, a.rate, a.channels, pa_sample_format_to_string(a.format), b.rate, b.channels, pa_sample_format_to_string(b.format)); ts = pa_rtclock_now(); pa_assert_se(resampler = pa_resampler_new(pool, &a, NULL, &b, NULL, crossover_freq, method, 0)); pa_log_info("init: %llu", (long long unsigned)(pa_rtclock_now() - ts)); i.memblock = pa_memblock_new(pool, pa_usec_to_bytes(1*PA_USEC_PER_SEC, &a)); ts = pa_rtclock_now(); i.length = pa_memblock_get_length(i.memblock); i.index = 0; while (seconds--) { pa_resampler_run(resampler, &i, &j); if (j.memblock) pa_memblock_unref(j.memblock); } pa_log_info("resampling: %llu", (long long unsigned)(pa_rtclock_now() - ts)); pa_memblock_unref(i.memblock); pa_resampler_free(resampler); goto quit; } for (a.format = 0; a.format < PA_SAMPLE_MAX; a.format ++) { for (b.format = 0; b.format < PA_SAMPLE_MAX; b.format ++) { pa_resampler *forth, *back; pa_memchunk i, j, k; pa_log_debug("=== %s -> %s -> %s -> /2", pa_sample_format_to_string(a.format), pa_sample_format_to_string(b.format), pa_sample_format_to_string(a.format)); pa_assert_se(forth = pa_resampler_new(pool, &a, NULL, &b, NULL, crossover_freq, method, 0)); pa_assert_se(back = pa_resampler_new(pool, &b, NULL, &a, NULL, crossover_freq, method, 0)); i.memblock = generate_block(pool, &a); i.length = pa_memblock_get_length(i.memblock); i.index = 0; pa_resampler_run(forth, &i, &j); pa_resampler_run(back, &j, &k); dump_block("before", &a, &i); dump_block("after", &b, &j); dump_block("reverse", &a, &k); pa_memblock_unref(i.memblock); pa_memblock_unref(j.memblock); pa_memblock_unref(k.memblock); pa_resampler_free(forth); pa_resampler_free(back); } } quit: if (pool) pa_mempool_free(pool); return ret; }
static ssize_t r3964_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count) { struct r3964_info *pInfo = (struct r3964_info *)tty->disc_data; struct r3964_block_header *pHeader; struct r3964_client_info *pClient; unsigned char *new_data; TRACE_L("write request, %d characters", count); /* * Verify the pointers */ if (!pInfo) return -EIO; /* * Ensure that the caller does not wish to send too much. */ if (count > R3964_MTU) { if (pInfo->flags & R3964_DEBUG) { TRACE_L(KERN_WARNING "r3964_write: truncating user " "packet from %u to mtu %d", count, R3964_MTU); } count = R3964_MTU; } /* * Allocate a buffer for the data and copy it from the buffer with header prepended */ new_data = kmalloc(count + sizeof(struct r3964_block_header), GFP_KERNEL); TRACE_M("r3964_write - kmalloc %p", new_data); if (new_data == NULL) { if (pInfo->flags & R3964_DEBUG) { printk(KERN_ERR "r3964_write: no memory\n"); } return -ENOSPC; } pHeader = (struct r3964_block_header *)new_data; pHeader->data = new_data + sizeof(struct r3964_block_header); pHeader->length = count; pHeader->locks = 0; pHeader->owner = NULL; pClient = findClient(pInfo, task_pid(current)); if (pClient) { pHeader->owner = pClient; } memcpy(pHeader->data, data, count); /* We already verified this */ if (pInfo->flags & R3964_DEBUG) { dump_block(pHeader->data, count); } /* * Add buffer to transmit-queue: */ add_tx_queue(pInfo, pHeader); trigger_transmit(pInfo); return 0; }
int main(int argc, char **argv) { puts("Copyright (c) 2001-2010 pinc Software."); if (argc < 2 || !strcmp(argv[1], "--help")) { char *filename = strrchr(argv[0],'/'); fprintf(stderr,"usage: %s [-srib] <device> [allocation_group start]\n" "\t-s\tdump superblock\n" "\t-r\tdump root node\n" " the following options need the allocation_group/start " "parameters:\n" "\t-i\tdump inode\n" "\t-b\tdump b+tree\n" "\t-v\tvalidate b+tree\n" "\t-h\thexdump\n" "\t-o\tshow disk offsets\n", filename ? filename + 1 : argv[0]); return -1; } bool dumpRootNode = false; bool dumpInode = false; bool dumpSuperBlock = false; bool dumpBTree = false; bool validateBTree = false; bool dumpHex = false; bool showOffsets = false; while (*++argv) { char *arg = *argv; if (*arg == '-') { while (*++arg && isalpha(*arg)) { switch (*arg) { case 's': dumpSuperBlock = true; break; case 'r': dumpRootNode = true; break; case 'i': dumpInode = true; break; case 'b': dumpBTree = true; break; case 'v': validateBTree = true; break; case 'h': dumpHex = true; break; case 'o': showOffsets = true; break; } } } else break; } Disk disk(argv[0]); if (disk.InitCheck() < B_OK) { fprintf(stderr, "Could not open device or file: %s\n", strerror(disk.InitCheck())); return -1; } putchar('\n'); if (!dumpSuperBlock && !dumpRootNode && !dumpInode && !dumpBTree && !dumpHex) { printf(" Name:\t\t\t\"%s\"\n", disk.SuperBlock()->name); printf(" (disk is %s)\n\n", disk.ValidateSuperBlock() == B_OK ? "valid" : "invalid!!"); printf(" Block Size:\t\t%" B_PRIu32 " bytes\n", disk.BlockSize()); printf(" Number of Blocks:\t%12" B_PRIdOFF "\t%10g MB\n", disk.NumBlocks(), disk.NumBlocks() * disk.BlockSize() / (1024.0*1024)); if (disk.BlockBitmap() != NULL) { printf(" Used Blocks:\t\t%12" B_PRIdOFF "\t%10g MB\n", disk.BlockBitmap()->UsedBlocks(), disk.BlockBitmap()->UsedBlocks() * disk.BlockSize() / (1024.0*1024)); printf(" Free Blocks:\t\t%12" B_PRIdOFF "\t%10g MB\n", disk.BlockBitmap()->FreeBlocks(), disk.BlockBitmap()->FreeBlocks() * disk.BlockSize() / (1024.0*1024)); } int32 size = (disk.AllocationGroups() * disk.SuperBlock()->blocks_per_ag); printf(" Bitmap Size:\t\t%" B_PRIu32 " bytes (%" B_PRId32 " blocks, %" B_PRId32 " per allocation group)\n", disk.BlockSize() * size, size, disk.SuperBlock()->blocks_per_ag); printf(" Allocation Groups:\t%" B_PRIu32 "\n\n", disk.AllocationGroups()); dump_block_run(" Log:\t\t\t", disk.Log()); printf(" (was %s)\n\n", disk.SuperBlock()->flags == SUPER_BLOCK_CLEAN ? "cleanly unmounted" : "not unmounted cleanly!"); dump_block_run(" Root Directory:\t", disk.Root()); putchar('\n'); } else if (dumpSuperBlock) { dump_super_block(disk.SuperBlock()); putchar('\n'); } if (disk.ValidateSuperBlock() < B_OK) { fprintf(stderr, "The disk's superblock is corrupt (or it's not a BFS " "device)!\n"); return 0; } if (dumpRootNode) { bfs_inode inode; if (disk.ReadAt(disk.ToOffset(disk.Root()), (void *)&inode, sizeof(bfs_inode)) < B_OK) { fprintf(stderr,"Could not read root node from disk!\n"); } else { puts("Root node:\n-----------------------------------------"); dump_inode(NULL, &inode, showOffsets); dump_indirect_stream(disk, &inode, showOffsets); putchar('\n'); } } char buffer[disk.BlockSize()]; bfs_inode* bfsInode = (bfs_inode*)buffer; block_run run; Inode *inode = NULL; if (dumpInode || dumpBTree || dumpHex || validateBTree) { // Set the block_run to the right value (as specified on the command // line) if (!argv[1]) { fprintf(stderr, "The -i/b/f options need the allocation group and " "starting offset (or the block number) of the node to dump!\n"); return -1; } run = parseBlockRun(disk, argv[1], argv[2]); if (disk.ReadAt(disk.ToOffset(run), buffer, disk.BlockSize()) <= 0) { fprintf(stderr,"Could not read node from disk!\n"); return -1; } inode = Inode::Factory(&disk, bfsInode, false); if (inode == NULL || inode->InitCheck() < B_OK) { fprintf(stderr,"Not a valid inode!\n"); delete inode; inode = NULL; } } if (dumpInode) { printf("Inode at block %" B_PRIdOFF ":\n------------------------------" "-----------\n", disk.ToBlock(run)); dump_inode(inode, bfsInode, showOffsets); dump_indirect_stream(disk, bfsInode, showOffsets); dump_double_indirect_stream(disk, bfsInode, showOffsets); dump_small_data(inode); putchar('\n'); } if (dumpBTree && inode != NULL) { printf("B+Tree at block %" B_PRIdOFF ":\n-----------------------------" "------------\n", disk.ToBlock(run)); if (inode->IsDirectory() || inode->IsAttributeDirectory()) { dump_bplustree(disk, (Directory *)inode, inode->Size(), dumpHex); putchar('\n'); } else fprintf(stderr, "Inode is not a directory!\n"); } if (validateBTree && inode != NULL) { printf("Validating B+Tree at block %" B_PRIdOFF ":\n------------------" "-----------------------\n", disk.ToBlock(run)); if (inode->IsDirectory() || inode->IsAttributeDirectory()) { BPlusTree *tree; if (((Directory *)inode)->GetTree(&tree) == B_OK) { if (tree->Validate(true) < B_OK) puts("B+Tree is corrupt!"); else puts("B+Tree seems to be okay."); } } else fprintf(stderr, "Inode is not a directory!\n"); } if (dumpHex) { printf("Hexdump from inode at block %" B_PRIdOFF ":\n-----------------" "------------------------\n", disk.ToBlock(run)); dump_block(buffer, disk.BlockSize()); putchar('\n'); } delete inode; return 0; }