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;
}
}
