static void print_httppost (struct curl_httppost *hp) { struct curl_httppost *p = hp; int i = 0; while (p != NULL) { fprintf (stderr, "\t\t%d: name: ", i); print_mem (p->name, p->namelength); fprintf (stderr, "\n\t\t contents: "); print_mem (p->contents, p->contentslength); fprintf (stderr, "\n\t\t buffer: "); print_mem (p->buffer, p->bufferlength); fprintf (stderr, "\n\t\t contenttype: "); print_mem (p->contenttype, xstrlen (p->contenttype)); fprintf (stderr, "\n\t\t contentheader: "); print_slist (p->contentheader); fprintf (stderr, "\n\t\t showfilename: "); print_mem (p->showfilename, xstrlen (p->showfilename)); fprintf (stderr, "\n\t\t flags: 0x%lx", p->flags); fprintf (stderr, "\n"); i++; p = p->next; } }
static void parse_print_value (Widget w, XtPointer client_data, XtPointer call_data) { Arg args[10]; String value1, value2; Widget form = XtParent (w); XtSetArg (args[0], XtNstring, &value1); XtGetValues (print_field1_text, args, ONE); XtSetArg (args[0], XtNstring, &value2); XtGetValues (print_field2_text, args, ONE); XtPopdown (XtParent (form)); destroy_popup_prompt (NULL, (XtPointer) form, NULL); if (!streq (value1, "")) { mem_addr from, to; from = strtoul (value1, NULL, 0); to = strtoul (value2, NULL, 0); if (streq (value2, "")) print_mem (from); else for ( ; from <= to; from+= BYTES_PER_WORD) print_mem (from); } }
int main(int argc, char **argv) { long long mem_size=0; mem_size=1024*1024; mem_size=get_mem_size_iomem(); printf("IOMEM:\n"); printf("\traw: %lld\n",mem_size); printf("\tpretty: "); print_mem(mem_size); mem_size=get_mem_size_stat(); printf("KCORE:\n"); printf("\traw: %lld\n",mem_size); printf("\tpretty: "); print_mem(mem_size); mem_size=get_mem_size_sysinfo(); printf("SYSINFO:\n"); printf("\traw: %lld\n",mem_size); printf("\tpretty: "); print_mem(mem_size); mem_size=get_mem_size_meminfo(); printf("MEMINFO:\n"); printf("\traw: %lld\n",mem_size); printf("\tpretty: "); print_mem(mem_size); mem_size=get_mem_size(); printf("DEFAULT:\n"); printf("\traw: %lld\n",mem_size); printf("\tpretty: "); print_mem(mem_size); return 0; }
int gcollector_test() { char *str1, *str3, *str4; int *str5, *str7, *str8; char *new_str; printf("Info: sizeof(char): %zu\n" " sizeof(int): %zu\n" " sizeof(double): %zu\n" " sizeof(float):\n\n %zu\n", sizeof(char), sizeof(int), sizeof(double), sizeof(float) ); print_mem(); str1 = (char *)allocate(5 * sizeof(char)); str3 = (char *)allocate(5 * sizeof(char)); str4 = (char *)allocate(5 * sizeof(char)); str5 = (int *)allocate(5 * sizeof(int)); str7 = (int *)allocate(5 * sizeof(int)); str8 = (int *)allocate(5 * sizeof(int)); print_mem(); getchar(); deallocate(str8); print_mem(); getchar(); deallocate(str5); deallocate(str1); print_mem(); getchar(); return gcollector(); }
void xc_dom_log_memory_footprint(struct xc_dom_image *dom) { xc_dom_printf("domain builder memory footprint\n"); xc_dom_printf(" allocated\n"); print_mem(" malloc", dom->alloc_malloc); print_mem(" anon mmap", dom->alloc_mem_map); xc_dom_printf(" mapped\n"); print_mem(" file mmap", dom->alloc_file_map); print_mem(" domU mmap", dom->alloc_domU_map); }
void xc_dom_log_memory_footprint(struct xc_dom_image *dom) { DOMPRINTF("domain builder memory footprint"); DOMPRINTF(" allocated"); print_mem(dom, " malloc", dom->alloc_malloc); print_mem(dom, " anon mmap", dom->alloc_mem_map); DOMPRINTF(" mapped"); print_mem(dom, " file mmap", dom->alloc_file_map); print_mem(dom, " domU mmap", dom->alloc_domU_map); }
void print_ip_hdr(IP_HDR *ip_pkt){ unsigned char c = 0; printf("IP pkt %p IP pkt +1 %p\n",ip_pkt,(void *)ip_pkt+1); printf("Version and header lenght\n"); print_mem((char*)ip_pkt,sizeof(char)); printf(" ver(dec) %u hdr_len(dec) %u\n",ip_pkt->ver,ip_pkt->hdr_len); printf("ToS and ECN\n"); print_mem((char *)ip_pkt+sizeof(char),sizeof(char)); printf(" TOS %u ECN %u\n",ip_pkt->dscp,ip_pkt->ecn); printf("Total lenght\n"); print_mem((char *)&(ip_pkt->tot_len),sizeof(short)); printf(" Integer Len %u\n",ntohs(ip_pkt->tot_len)); printf("Packet Id \n"); print_mem((char *)&(ip_pkt->id),sizeof(short)); printf(" Packet ID(dec) %u\n",ntohs(ip_pkt->id)); printf("Flag and fragment\n"); print_mem((char *)&(ip_pkt->id)+sizeof(short),sizeof(short)); printf("TTL and Protocol\n"); print_mem((char *)&(ip_pkt->ttl),sizeof(short)); printf(" TTL(dec) %u Protocol(dec) %u\n",ip_pkt->ttl,ip_pkt->protocol); printf("Header Checksum\n"); print_mem((char *)&(ip_pkt->hdr_chksm),sizeof(short)); printf(" Header Checksum(dec) %u\n",ip_pkt->hdr_chksm); printf("Source IP\n"); print_mem((char *)&(ip_pkt->src.addr),4); printf("Destination IP\n"); print_mem((char *)&(ip_pkt->dst.addr),4); // printf("verification %u\n",ipv4_chksm((short *)ip_pkt,ip_pkt->hdr_len*2)); // ip_pkt->hdr_chksm=0; // printf("Chksm via calculation %x\n",ipv4_chksm((short *)ip_pkt,ip_pkt->hdr_len*2)); //print_mem }
static void * smalloc (unsigned long size) { struct mem *head, *tail; static unsigned short count; int i; int sum; unsigned char *ptr; MPRINTK ("smalloc (size = %d)\n",size); head = malloc (size + 2*sizeof (*head)); if (head == NULL) return (NULL); tail = (struct mem *)((unsigned char *)(head+1) + size); head->other = tail; tail->other = head; tail->len = size; head->len = size; for (i = 0; i < 10; i++) { tail->buff[i]=count++; head->buff[i]=count; } ptr = (unsigned char *)head; head->check = 0; sum = 0; for (i = 0; i < sizeof (*head); i ++) { sum+= ptr[i]; } head->check = ~sum; ptr = (unsigned char *)tail; tail->check = 0; sum = 0; for (i = 0; i < sizeof (*head); i ++) { sum+= ptr[i]; } tail->check = ~sum; MPRINTK ("head = %X:\n", head); print_mem(head); MPRINTK ("tail = %X:\n", tail); print_mem(tail); return (head+1); }
static int swan_ts_read_registers_main(int argc, char *argv[]) { int ret; u16 offset; u16 count; char *buff; assert(argc > 1); offset = text2value_unsigned(argv[1], NULL, 10); count = argc > 2 ? text2value_unsigned(argv[2], NULL, 10) : 1; buff = malloc(count); if (buff == NULL) { pr_red_info("malloc"); return -ENOMEM; } println("offset = %d, count = %d", offset, count); ret = swan_ts_read_registers(NULL, offset, buff, count); if (ret < 0) { pr_red_info("swan_ts_read_registers"); goto out_free_buff; } print_mem((u8 *) buff, count); out_free_buff: free(buff); return ret; }
static void test_vsprint(const char *fmt, ...) { #define buf_size 200 char buf[buf_size]; va_list ap; va_start(ap, fmt); // vsnprintf(buf, buf_size, fmt, ap); const char *c = fmt; print_mem((const char *)&fmt, 0x100); while (*c) { switch (*c) { case '%': switch (*(++c)) { case 's': { char *s = va_arg(ap, char *); logmsgf("%%s: 0x%x, *s=0x%x\n", (uint)s, (uint)*s); } break; case 'd': case 'u': case 'x': { int arg = va_arg(ap, int); logmsgf("%%d: 0x%x\n", (uint)arg); } break; default: logmsg("Unknown operand for %%\n"); } } ++c; } va_end(ap); logmsgf("\n%s\n", buf); }
SCM DLL_PUBLIC cl_dump_handle (SCM handle) { handle_post_t *hp; SCM_ASSERT (_scm_is_handle (handle), handle, SCM_ARG1, "%curl-dump-handle"); hp = _scm_to_handle (handle); fprintf (stderr, "<#handle %p>\n", hp); fprintf (stderr, "\t handle %p\n", hp->handle); fprintf (stderr, "\t postfields %p\n", hp->postfields); fprintf (stderr, "\t postfieldsize %zu\n", hp->postfieldsize); print_mem (hp->postfields, hp->postfieldsize); fprintf (stderr, "\t httppost %p\n", hp->httppost); print_httppost (hp->httppost); fprintf (stderr, "\t httpheader %p\n", hp->httpheader); print_slist (hp->httpheader); fprintf (stderr, "\thttp200aliases %p\n", hp->http200aliases); print_slist (hp->http200aliases); fprintf (stderr, "\t mail_rcpt %p\n", hp->mail_rcpt); print_slist (hp->mail_rcpt); fprintf (stderr, "\t quote %p\n", hp->quote); print_slist (hp->quote); fprintf (stderr, "\t postquote %p\n", hp->postquote); print_slist (hp->postquote); fprintf (stderr, "\t prequote %p\n", hp->prequote); print_slist (hp->prequote); fprintf (stderr, "\t resolve %p\n", hp->resolve); print_slist (hp->resolve); fprintf (stderr, "\t telnetoptions %p\n", hp->telnetoptions); print_slist (hp->telnetoptions); fflush (stderr); return SCM_UNDEFINED; }
void *xc_dom_malloc_page_aligned(struct xc_dom_image *dom, size_t size) { struct xc_dom_mem *block; block = malloc(sizeof(*block)); if ( block == NULL ) { DOMPRINTF("%s: allocation failed", __FUNCTION__); return NULL; } memset(block, 0, sizeof(*block)); block->len = size; block->ptr = mmap(NULL, block->len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); if ( block->ptr == MAP_FAILED ) { DOMPRINTF("%s: mmap failed", __FUNCTION__); free(block); return NULL; } block->type = XC_DOM_MEM_TYPE_MMAP; block->next = dom->memblocks; dom->memblocks = block; dom->alloc_malloc += sizeof(*block); dom->alloc_mem_map += block->len; if ( size > (100 * 1024) ) print_mem(dom, __FUNCTION__, size); return block->ptr; }
static int swan_ts_read_data_main(int argc, char *argv[]) { int ret; u16 count; char *buff; count = argc > 1 ? text2value_unsigned(argv[1], NULL, 10) : 1; buff = malloc(count); if (buff == NULL) { pr_red_info("malloc"); return -ENOMEM; } println("count = %d", count); ret = swan_ts_read_data(NULL, buff, count); if (ret < 0) { pr_red_info("swan_ts_read_data"); goto out_free_buff; } print_mem((u8 *) buff, count); out_free_buff: free(buff); return ret; }
int main() { init_env(); // Poorly named. Has nothing to do with env alist. init_mem(); uptr_t *env = refer(NIL); init_syms(env); uptr_t *form_p = refer(NIL); while(1) { print_env(env); print_mem(); printf_P(PSTR("> ")); *form_p = read_form(stdin); while(getc(stdin) != '\r'); print_form(eval(env, *form_p)); printf_P(PSTR("\n")); // print_mem(); __GC__(); } release(2); // Just a formality really... return 0; }
/** do the stats command */ static void do_stats(SSL* ssl, struct daemon_remote* rc, int reset) { struct daemon* daemon = rc->worker->daemon; struct stats_info total; struct stats_info s; int i; log_assert(daemon->num > 0); /* gather all thread statistics in one place */ for(i=0; i<daemon->num; i++) { server_stats_obtain(rc->worker, daemon->workers[i], &s, reset); if(!print_thread_stats(ssl, i, &s)) return; if(i == 0) total = s; else server_stats_add(&total, &s); } /* print the thread statistics */ total.mesh_time_median /= (double)daemon->num; if(!print_stats(ssl, "total", &total)) return; if(!print_uptime(ssl, rc->worker)) return; if(daemon->cfg->stat_extended) { if(!print_mem(ssl, rc->worker, daemon)) return; if(!print_hist(ssl, &total)) return; if(!print_ext(ssl, &total)) return; } }
void *xc_dom_malloc_page_aligned(struct xc_dom_image *dom, size_t size) { struct xc_dom_mem *block; block = malloc(sizeof(*block)); if ( block == NULL ) return NULL; memset(block, 0, sizeof(*block)); block->mmap_len = size; block->mmap_ptr = mmap(NULL, block->mmap_len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0); if ( block->mmap_ptr == MAP_FAILED ) { free(block); return NULL; } block->next = dom->memblocks; dom->memblocks = block; dom->alloc_malloc += sizeof(*block); dom->alloc_mem_map += block->mmap_len; if ( size > (100 * 1024) ) print_mem(__FUNCTION__, size); return block->mmap_ptr; }
HANDLE init_setup(LPSTR filename) { DWORD dwFileSize = 0, dwRet, i, chunkSize; HANDLE hFile; LPCHUNK chunk; /* Open file */ hFile = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); DIE(hFile == INVALID_HANDLE_VALUE, "CreateFile"); /* Get file size */ dwFileSize = GetFileSize(hFile, NULL ); DIE(dwFileSize == INVALID_FILE_SIZE, "GetFileSize"); /* Get number of integers in file */ N = dwFileSize / sizeof(DWORD); chunkSize = (N - 1 + NO_THREADS) / NO_THREADS; /* Map file */ pmap = MapFile(hFile, dwFileSize); print_mem(pmap, N); /* TODO - Create threads and assign chunks */ for (i = 0; i < NO_THREADS; i++){ chunk = malloc(sizeof(CHUNK)); chunk->dwLen = ((i+1) * chunkSize > N ? N - (i * chunkSize) : chunkSize); chunk->lpMem = (LPDWORD)pmap + i * chunkSize; //printf("chunk.len = %d chunk start = %p\n", chunk->dwLen, chunk->lpMem); thData[i].threadId = i; thData[i].lpChunk = chunk; threads[i] = CreateThread( NULL, 0, ThreadFunc, &thData[i], CREATE_SUSPENDED, /* wait for all threads to start */ NULL ); DIE(threads[i] == INVALID_HANDLE_VALUE, "CreateThread"); } /* resume threads to avoid posible race */ for (i = 0; i < NO_THREADS; i++){ dwRet = ResumeThread(threads[i]); DIE(dwRet == FALSE, "ResumeThread"); } return hFile; }
uint8_t MAC_Check(uint8_t* host_mac,uint8_t* response_mac){ printf("The host's MAC is: \r\n"); print_mem(host_mac,MAC_CHALLENGE_SIZE,16); delay_ms(100); printf("The response MAC is: \r\n"); print_mem(response_mac,MAC_CHALLENGE_SIZE,16); if (sizeof(host_mac) == sizeof(response_mac) && memcmp(response_mac, host_mac, MAC_CHALLENGE_SIZE) == 0){ printf("Authentication Succeed"); return AUTHENTED; }else{ printf("Authentication Failed"); return AUTH_FAILED; } }
void print_mem(memory_block * mem) { if (mem == NULL) return; printf("mem block at addr 0x%x, has size of 0x%x", (int) mem, (int) mem->size); print_mem(mem->oNext); }
/* Interesting test case. Divides SIZE into 4 blocks and allocates smalloc each SIZE / 4 block of memory Tests - ability for smalloc to handle adding to an empty allocated_list - ability for smalloc to handle adding to an allocated_list with existing blocks - ability for smalloc to handle when smalloc is called for num_bytes > available size in freelist - ability for freelist to handle when freelist has no memory blocks available - ability for freelist to handle when the size in freelist is equal to the number of bytes called by smalloc (when the last memory block at ptrs[3] is called), and freelist should free this memory block from the list rather than break it into chunks */ int main(void) { mem_init(SIZE); char *ptrs[10]; int i; //Call smalloc 4 times ptrs[0] = smalloc(SIZE * 2); for(i = 0; i <4; i++) { int num_bytes = SIZE / 4; ptrs[i] = smalloc(num_bytes); write_to_mem(num_bytes, ptrs[i], i); } printf("List of allocated blocks:\n"); print_allocated(); printf("List of free blocks:\n"); print_free(); printf("Contents of allocated memory:\n"); print_mem(); printf("freeing %p result = %d\n", ptrs[0], sfree(ptrs[0])); printf("freeing %p result = %d\n", ptrs[1], sfree(ptrs[1])); printf("freeing %p result = %d\n", ptrs[2], sfree(ptrs[2])); printf("freeing %p result = %d\n", ptrs[3], sfree(ptrs[3])); // sfree already called for address at ptrs[1]. Case should be handled printf("freeing %p result = %d\n", ptrs[1], sfree(ptrs[1])); printf("List of allocated blocks:\n"); print_allocated(); printf("List of free blocks:\n"); print_free(); printf("Contents of allocated memory:\n"); print_mem(); mem_clean(); return 0; }
static void rx_loop() { int ret; while (!the_working_paras.need_exit) { ret=fd_readable(the_working_paras.sockfd, 0, 10000); if (ret<=0) { if (ret<0 && !the_working_paras.no_verbose) ERR_DBG_PRINT("test fd failed"); continue; } ret=read(the_working_paras.sockfd ,the_working_paras.buf ,sizeof(the_working_paras.buf)); INC_STAT(the_stat_data.rx_times_total); if (ret>0) { INC_STAT(the_stat_data.rx_times_succ); INC_STAT_VALUE(the_stat_data.rx_bytes, ret); if (!the_working_paras.no_verbose) { printf("[%"PRIu64"]got %d bytes\n" ,the_stat_data.rx_times_succ ,ret); if (!the_working_paras.no_prt_pkt) { printf("the data contents is:\n"); print_mem(the_working_paras.buf, ret); } } } else { INC_STAT(the_stat_data.rx_times_fail); if (!the_working_paras.no_verbose) ERR_DBG_PRINT("rx failed"); break; } printf("\n\n"); continue; } }
static int swan_ts_poll_registers_main(int argc, char *argv[]) { int ret; u16 offset; u16 count; u32 timeout; int fd; char *buff; const char *devpath; assert(argc > 2); offset = text2value_unsigned(argv[1], NULL, 10); count = text2value_unsigned(argv[2], NULL, 10); timeout = argc > 3 ? text2value_unsigned(argv[3], NULL, 10) : 200; devpath = argc > 4 ? argv[4] : SWAN_TS_DEFAULT_DEVICE; println("offset = %d, count = %d, timeout = %d, devpath = %s", offset, count, timeout, devpath); buff = malloc(count); if (buff == NULL) { pr_red_info("malloc"); return -ENOMEM; } fd = swan_ts_open_misc_device(devpath, 0); if (fd < 0) { pr_red_info("swan_ts_open_misc_device"); ret = fd; goto out_free_buff; } while (1) { msleep(timeout); ret = swan_ts_read_registers_fd(fd, offset, buff, count); if (ret < 0) { continue; } print_mem((u8 *) buff, count); } close(fd); out_free_buff: free(buff); return ret; }
void md5_test(const char *str) { MD5_CTX context; unsigned char digest[16]; unsigned int len = strlen (str); MD5_Init (&context); MD5_Update (&context, str, len); MD5_Final (digest, &context); print_mem(digest,16); }
uint8_t MAC_RSP(uint8_t* host_fix,uint8_t* host_rn,uint8_t*buffer){ uint8_t ret = ATCA_SUCCESS; uint8_t randomized_param[RANDOM_NUM_SIZE]; memcpy(randomized_param,rn,RANDOM_NUM_SIZE); delay_ms(100); printf("\r\n"); printf("the fixed challenge is: \r\n"); print_mem(host_fix, RANDOM_NUM_SIZE, 16); delay_ms(100); printf("the random number is: \r\n"); print_mem(host_rn, RANDOM_NUM_SIZE, 16); ret=cademo_mac_fixed_chal_randomized(AUTH_KEY_ID,host_fix,randomized_param,tempkey); delay_ms(100); printf("the temperate key is: \r\n"); print_mem(tempkey, sizeof(tempkey), 16); delay_ms(100); sha256_hmac( tempkey, MAC_CHALLENGE_SIZE,host_rn, RANDOM_NUM_SIZE,buffer, 0 ); printf("the MAC is: \r\n"); print_mem(buffer,MAC_CHALLENGE_SIZE, 16); return ret; }
main(int argc, char **argv) { int i, min, max; mem_reset(); for (i=1; i < argc; i++) { get_range(argv[i], &min, &max); mem_skip(min, max); } print_mem(); }
void *xc_dom_malloc(struct xc_dom_image *dom, size_t size) { struct xc_dom_mem *block; block = malloc(sizeof(*block) + size); if ( block == NULL ) return NULL; memset(block, 0, sizeof(*block) + size); block->next = dom->memblocks; dom->memblocks = block; dom->alloc_malloc += sizeof(*block) + size; if ( size > (100 * 1024) ) print_mem(__FUNCTION__, size); return block->memory; }
int print_hub(t_taupe *taupe) { wclear(taupe->top->win); print_sys(taupe->sys, taupe->top); print_task(taupe->task, taupe->top); print_cpu(taupe->cpu, taupe->top); print_mem(taupe->mem, taupe->top); if (taupe->signal->on) { print_opt(taupe->signal, "Send Signal"); print_signal(taupe->signal, taupe->pid); } else if (taupe->sort->on) print_opt(taupe->sort, "Sort By"); print_main(taupe); return (0); }
/** print statistics out of memory structures */ static void do_stats_shm(struct config_file* cfg, struct ub_stats_info* stats, struct ub_shm_stat_info* shm_stat) { int i; char nm[32]; for(i=0; i<cfg->num_threads; i++) { snprintf(nm, sizeof(nm), "thread%d", i); pr_stats(nm, &stats[i+1]); } pr_stats("total", &stats[0]); print_uptime(shm_stat); if(cfg->stat_extended) { print_mem(shm_stat); print_hist(stats); print_extended(stats); } }
int main(int argc, const char *argv[]) { if (argc != 2) { usage: printf("USAGE: %s apr|pocore\n", argv[0]); return EXIT_FAILURE; } if (strcmp(argv[1], "apr") == 0) time_apr(); else if (strcmp(argv[1], "pocore") == 0) time_pocore(); else goto usage; print_mem(); return EXIT_SUCCESS; }
void ft_print_large(void) { t_large *large; if (!g_page.large_head) return ; large = (void *)g_page.large_head; while (large) { ft_putstr("LARGE : "); ft_atoi_hex((void *)(large->page) + 24); ft_putstr(" - "); ft_atoi_hex((void *)(large->page) + large->size + 24); ft_putstr(" : "); ft_putnbr(large->size); ft_putstr(" octets "); print_mem((void *)(large->page) + 24); large = large->next; } }