Beispiel #1
0
int main(void)
{
   int i;
   void* orig_ds = sbrk(0);
   void* ds = orig_ds;
   void* vals[10];
   void* res;
   void *prev;
#define EOL ((void*)( ~(long)0 ))
   vals[0] = (void*)0;
   vals[1] = (void*)1;
   vals[2] = ds - 0x1;          // small shrink
   vals[3] = ds;
   vals[4] = ds + 0x1000;       // small growth
   vals[5] = ds + 0x40000000;   // too-big growth
   vals[6] = ds + 0x500;        // shrink a little, but still above start size
   vals[7] = ds - 0x1;          // shrink below start size
//   vals[8] = ds - 0x1000;       // shrink a lot below start size (into text)
//   vals[9] = EOL;
   vals[8] = EOL;

   for (i = 0; EOL != vals[i]; i++) {
      res = brk(vals[i]);
   }

   assert( 0 == brk(orig_ds) );  // libc brk()

   for (i = 0; EOL != vals[i]; i++) {
      res = (void*)brk(vals[i]);
   }

   return 0;
}
Beispiel #2
0
void *sbrk(intptr_t incr)
{
        uintptr_t oldbrk;

        /* If we don't have a saved break, find it from the kernel */
        if (!__curbrk) {
                if (0 > (long)(__curbrk = (void *) trap(SYS_brk, (uint32_t) NULL))) {
                        return (void *) -1;
                }
        }

        oldbrk = (uintptr_t) __curbrk;

        /* Increment or decrement the saved break */

        if (incr < 0) {
                if ((uintptr_t) - incr > oldbrk) {
                        return (void *) -1;
                } else if (brk((void *)(oldbrk - (uintptr_t) - incr)) < 0) {
                        return (void *) -1;
                }
        } else if (incr > 0) {
                if (brk((void *)(oldbrk + (uintptr_t) incr)) < 0) {
                        return (void *) -1;
                }
        }
        return (void *) oldbrk;
}
Beispiel #3
0
void *
sbrk(unsigned int ptrdiff)
{

   void *newend;

   /* have we been initialized yet? */
   if (curheap == 0) {
      curheap = (void *) brk(0);
   }

   /* are they just querying the current heap? */
   if (ptrdiff == 0) {
      return curheap;
   }

   /* where we want our new heap to end */
   newend = curheap + ptrdiff;

   /* can we get the memory? */
   if (brk(newend) < 0) {
      return 0;
   }

   /* we got the memory */
   curheap = newend;
   return curheap - ptrdiff;
}
Beispiel #4
0
int
openbsd_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED, size_t off ATTRIBUTE_UNUSED)
{
  void *addr;

  if (size == 0)
    return -1;

  /* sanity check base address */
  addr = sbrk(0);
  if (addr == (void *)-1 || base < addr)
    return -1;

  /* set base for sbrk */
  if (brk(base) != 0)
    return -1;

  /* attempt to get the memory */
  addr = sbrk(size);
  if (addr == (void *)-1)
    return -1;

  /* sanity check the result */
  if (addr != base) {
    brk(base);
    return -1;
  }

  return 0;
}
Beispiel #5
0
void *
openbsd_gt_pch_get_address (size_t size, int fd ATTRIBUTE_UNUSED)
{
  void *base, *addr;
  size_t pgsz;

  if (size > INT_MAX)
          return NULL;

  pgsz = sysconf(_SC_PAGESIZE);
  if (pgsz == (size_t)-1)
    return NULL;

  base = sbrk(0);

  /* round up to nearest page */
  base = (void *)(((long)base + (pgsz - 1)) & ~(pgsz - 1));
  if (brk(base) != 0)
    return NULL;

  /* attempt to allocate size */
  addr = sbrk(size);
  if (addr == (void *)-1)
    return NULL;

  /* deallocate the memory */
  if (brk(base) != 0)
    return NULL;

  /* confirm addr is as expected */
  if (addr != base)
    return NULL;

  return base;
}
Beispiel #6
0
int main(void)
{
	//获取起始地址
	void* p = sbrk(0);
	printf("p = %p\n",p);

	//申请4个字节内存空间
	int res = brk(p+4);
	if(-1 == res)
	{
		perror("brk"),exit(-1);
	}
	printf("成功申请了4个字节的内存\n");
	void* cur = sbrk(0);
	printf("cur = %p\n",cur);

	//申请了4个字节
	brk(p+8);
	cur = sbrk(0);
	printf("cur = %p\n",cur);

	//释放了4个字节内存
	brk(p+4);
	cur = sbrk(0);
	printf("cur = %p\n",cur);

	//释放所有内存
	brk(p);
	return 0;
}
Beispiel #7
0
void free(void *ptr) {
  if (unlikely(!ptr)) {
    return;
  }
  pthread_mutex_lock(&list_lock);
  metadata_t* block_ptr = get_block(ptr);
  merge_block(block_ptr);

  if (unlikely(block_ptr->free != 0 || block_ptr->magic1 != MAGIC_USED || block_ptr->magic1 != block_ptr->magic2)) {
    printf(SEGFAULT);
    exit(-1);
  }
  alloc_count--;
  if (unlikely(alloc_count == 0)){
    brk(base);
    base = 0;
  } else if (block_ptr->next == NULL){
    block_ptr->prev->next = NULL;
    brk(block_ptr);
  } else {
    block_ptr->free = 1;
    block_ptr->magic1 = MAGIC_FREE;
    block_ptr->magic2 = MAGIC_FREE;
  }
  pthread_mutex_unlock(&list_lock);
}
Beispiel #8
0
void *sbrk(ssize_t increment)
{
  void *newbrk, *oldbrk;
  oldbrk= brk(0);
  if (!increment) return oldbrk;
  newbrk= brk(oldbrk + increment);
  if (newbrk == oldbrk) return (void *)-1;
  return oldbrk;
}
Beispiel #9
0
int main () {
  if (1) {
    if (x > 1 ) { foo(); brk(); }
    } else aaa();
  if (1)
    while (x > 1 ) { foo(); brk(); }
  else aaa();
  foo(); brk();
}
Beispiel #10
0
/*
 * Try to spend as much time as possible in kernelspace
 * to elapse ITIMER_PROF.
 */
static void kernel_loop(void)
{
	void *addr = sbrk(0);

	while (!done) {
		brk(addr + 4096);
		brk(addr);
	}
}
Beispiel #11
0
/*
 * ----------------------------------------------------------------------------
 * Free space previously allocated by malloc. This memory can now be used again
 * Also, colless any contiguous free nodes into one large free node to make
 * larger spaces available for larger allocation requests
 * ----------------------------------------------------------------------------
 */
void my_free(void *ptr){

  // Mark the node as free
  Node n = (Node)ptr - 1;
  n->free = 1;

  // If contiguous free space nodes exist, combine them into a single node
  // AKA: coalesce!
  // First look and see if a node has extra space behind it
  if (n->prev != NULL){
    if (n->prev->free == 1){
      n->prev->size = n->size + sizeof(struct node);
      n->prev->next = n->next;

      if (last == n)
        last = n->prev;

      if (cur == n)
        cur = n->prev;

      n = n->prev;
    }
  }

  //Now look and see if a node in front of the node is free
  if (n->next != NULL){
    if (n->next->free == 1){
      n->size += n->next->size + sizeof(struct node);
      n->next = n->next->next;
    }
  }

  // When the last node is free, we can cut it off and resize the heap to
  // contain only wnat we need
  // AKA: truncating
  if (n == last){
    if (last == first){
      first = 0;
      cur = 0;
      last = 0;
      brk((void*)(n));
    }

    else if (last == cur){
      cur = cur->prev;
      last = last->prev;
      last->next = NULL;
      brk((void*)(n-1));
    }

    else{
      last = last->prev;
      last->next = NULL;
      brk((void*)(n-1));
    }
  }
}
Beispiel #12
0
/*
 * Try to spend as much time as possible in kernelspace
 * to elapse ITIMER_PROF.
 */
static void kernel_loop(void)
{
	void *addr = sbrk(0);
	int err = 0;

	while (!done && !err) {
		err = brk(addr + 4096);
		err |= brk(addr);
	}
}
TEST(UNISTD_TEST, brk) {
  void* initial_break = get_brk();

  // The kernel aligns the break to a page.
  void* new_break = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(initial_break) + 1);
  ASSERT_EQ(0, brk(new_break));
  ASSERT_GE(get_brk(), new_break);

  new_break = page_align(reinterpret_cast<uintptr_t>(initial_break) + sysconf(_SC_PAGE_SIZE));
  ASSERT_EQ(0, brk(new_break));
  ASSERT_EQ(get_brk(), new_break);
}
int main()
{	
	//1.找到空闲空间的首地址
	int* p=(int*)sbrk(0);
	printf("sbrk(0):%p\n",p);
	//2.分配空间
	brk(p+1);
	printf("brk:%p\n",p);
	//3.使用空间
	*p=800;
	//4. 释放空间
	brk(p);
	
	return 0;
}
Beispiel #15
0
void testcase(unsigned long long *iterations)
{
	void *addr = sbrk(0);
	unsigned long page_size = getpagesize();

	while (1) {
		addr += page_size;
		brk(addr);

		addr -= page_size;
		brk(addr);

		(*iterations) += 2;
	}
}
int main() {
  void *addr;
  char *str;
  int i;

  /* get the current brk point */
  addr = sbrk(0);

  /* create a new brk point that is higher than the current
     and also page aligned */
  addr = (void*)(((int)addr & 0xfffff000)+ 0x2000);
  
  /* set the new brk to addr */
  if (brk(addr) != 0) {
    fprintf(stderr, "brk() failed: %s\n", strerror(errno));
    return -1;
  }

  str = ((char *)addr) - 10;

  /* fill in the string up to the brk point */
  for(i = 0; i < 10; i++)
    str[i] = 'f';

  /* call foo and cross our fingers */
  //printf("%s\n",str );
  foo(str);

  return 0;
}
static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const Locale& locale, const char* locale_name) {
  UErrorCode status = U_ZERO_ERROR;
  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
  ScopedResourceBundle fields(ures_getByKey(root.get(), "fields", NULL, &status));
  ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
  ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
  if (U_FAILURE(status)) {
    return false;
  }

  UnicodeString yesterday(ures_getUnicodeStringByKey(relative.get(), "-1", &status));
  UnicodeString today(ures_getUnicodeStringByKey(relative.get(), "0", &status));
  UnicodeString tomorrow(ures_getUnicodeStringByKey(relative.get(), "1", &status));
  if (U_FAILURE(status)) {
    ALOGE("Error getting yesterday/today/tomorrow for %s: %s", locale_name, u_errorName(status));
    return false;
  }

  // We title-case the strings so they have consistent capitalization (http://b/14493853).
  UniquePtr<BreakIterator> brk(BreakIterator::createSentenceInstance(locale, status));
  if (U_FAILURE(status)) {
    ALOGE("Error getting yesterday/today/tomorrow break iterator for %s: %s", locale_name, u_errorName(status));
    return false;
  }
  yesterday.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
  today.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
  tomorrow.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);

  setStringField(env, localeData, "yesterday", yesterday);
  setStringField(env, localeData, "today", today);
  setStringField(env, localeData, "tomorrow", tomorrow);
  return true;
}
Beispiel #18
0
int main () {
  int i;
  int inc_dec;
  int delta;
  intptr_t brk_stat;

  // loop to first increase, then decrease
  for (inc_dec = 1; inc_dec >= -1; inc_dec-=2) {
     // loop to increase(decrease) with small then big delta
     for (delta = 1; delta <= 400; delta+=399) {
        if (0) printf("initial brk value for inc_dec %d delta %d: %p\n",
               inc_dec, delta, sbrk(0));
        for (i=0; i<MAX; i++) {
           brk_stat = (intptr_t)brk(sbrk(0) + inc_dec * delta);
           if (brk_stat == -1) {
              printf("brk value at failure: %p\n", sbrk(0));
              perror ("brk() failed!\n");
              return 0;
           }
        }
        if (0) printf("resulting brk value for inc_dec %d delta %d: %p\n",
               inc_dec, delta, sbrk(0));
     }
  }

  return 0;
} 
Beispiel #19
0
void free(void *ptr){
  sum_frees++;
  num_allocated--;

  block_t current;
  if (valid_address(ptr)){
    current = get_block(ptr);
    current->free = 1;
    if(current->prev && current->prev->free){
      //merge with prev block if works
      current = merge_block(current->prev);
    }
    if (current->next){
      //merge with next
      merge_block(current);
    } else {
      if (current->prev){
        current->prev->next = NULL;
      } else {
        //no more blocks
        base = NULL;
      }
      brk(current);
    }
  } else {
    perror("invalid ptr at free");
  }
}
Beispiel #20
0
void * _PDCLIB_allocpages( int const n )
{
    if ( membreak == NULL )
    {
        /* first call, make sure end-of-heap is page-aligned */
        intptr_t unaligned = 0;
        membreak = sbrk( 0 );
        unaligned = _PDCLIB_PAGESIZE - (intptr_t)membreak % _PDCLIB_PAGESIZE;
        if ( unaligned < _PDCLIB_PAGESIZE )
        {
            /* end-of-heap not page-aligned - adjust */
            if ( sbrk( unaligned ) != membreak )
            {
                /* error */
                return NULL;
            }
            membreak = (char *)membreak + unaligned;
        }
    }
    /* increasing or decreasing heap - standard operation */
    void * oldbreak = membreak;
    membreak = (void *)( (char *)membreak + ( n * _PDCLIB_PAGESIZE ) );
    if ( brk( membreak ) == 0 )
    {
        /* successful */
        return oldbreak;
    }
    else
    {
        /* out of memory */
        membreak = oldbreak;
        return NULL;
    }
}
Beispiel #21
0
void* mm_malloc(size_t size)
{
	s_block_ptr active = first;
	s_block_ptr segment = NULL;
	s_block_ptr extend = sbrk(0); //returns break address

	//Search for free block in memory
		
	*last = active;
	if(active!=NULL) {
		
	}
	//Split block into segments if active size is less than block size
	segment = active;
	size_t comparisonsize = active->size;
	if((comparisonsize) < (sizeof(struct s_block))) {
		segment->free = 'true';
		active->free = 'false';
	}
	//Increase heap size when block too small
	else{
		if(extend !=NULL) {
			
			while(extend->size < active-size) {
				extend->size = extend->size + 4096; //4096 = page size
			}
			int result = brk(*extend);
			if(result == 0)
				extend->free = 'false';
		}
	}
}
void *_sbrk(intptr_t incr)
{
	void *oldbrk = curbrk;
	if (brk(oldbrk + incr) == -1)
		return (void *)-1;
	return oldbrk;
}
Beispiel #23
0
int main() {
  char *s;


  // sbrkはヒープ領域のブレーク値を加算して変更します。
  // プロセスのメモリ未割り当て領域を「ヒープ」といい、ヒープ上の未割り当てメモリの先頭アドレスを「ブレーク値」といいます。
  //
  // sbrkシステムコールはブレーク値をバイト数指定で加算します。 
  //    整数を指定してsbrkを実行すると、ヒープ領域にメモリを動的に割り当てます。
  //    負数を指定してsbrkを実行すると、その分のメモリは解放されます。 

  // [memo] "warning: comparison between pointer and integer [enabled by default]"のwarningエラーのため(void*)でキャストする
  if ((s = sbrk(13)) == (void*)-1) {  // 13 = "Hello World\n"
    perror("sbrk");
    return 1;
  }

  strcpy(s, "Hello World\n");
  write(1, s, 12);

  // brkシステムコール及びsbrkシステムコールを利用してブレーク値を変更することで、メモリの割り当てと解放を行うことができます。 
  // 
  // brkシステムコールはプロセスに新しいブレーク値を任意に設定します。 
  //    指定したブレーク値が現在のブレーク値より大きい場合には、ヒープ領域にメモリを割り当てます。
  //    指定したブレーク値が現在のブレーク値より小さい場合には、ヒープ領域に動的に割り当てられたメモリを解放します。 
  if (brk(s) < 0) {
    perror("brk");
    return 1;
  }

  return 0;
}
Beispiel #24
0
int main(){
    printf("below are address of type of process's mem\n");
    printf("Text location代码段:\n");
    printf("\tAddress of main(Code Segment):%p\n",main);
    printf("__________________________________\n");
    int stack_var0 = 2;
    printf("Stack Location栈段:\n");
    printf("\tInitial end of stack:%p\n",&stack_var0);
    int stack_var1 = 3;
    printf("\t new end of stack:%p\n",&stack_var1);
    printf("__________________________________\n");
    printf("Data Location:数据段\n");
    printf("\tAddress of data_var(Data Segment):%p\n",&data_var0);
    static int data_var1= 4;
    printf("\t NEW ned of data_var(Data Segment):%p\n",&data_var1);
    printf("__________________________________\n");
    printf("BSS Location:bss段\n");
    printf("\tAddress of bss_var:%p\n",&bss_var);
    printf("__________________________________\n");
    char *b = sbrk((ptrdiff_t)0);
    printf("Heap Location:\n");
    printf("\t Initial end of heap:%p\n",b);
    brk(b+4);
    b=sbrk((ptrdiff_t)0);
    printf("\tNew end of heap:%p\n",b);
    return 0;
}
Beispiel #25
0
/* Restore checkpoint header */
int
ckptRestoreHeader(ckptImage * image, size_t size, void **stack_start)
{
    struct ckptCheckpointHdr header;

    ckptReadChunkData(image, &header);

    if (header.np != CKPT_NP)
    {
        ckptLog(CKPT_LOG_ERROR, "Number of processes mismatch: was %d, now %d", header.np, CKPT_NUMBER);
        abort();
    }

    if (!ckptDisableMtimeCheck && header.mtime != ckptElfGetMtime())
    {
        ckptLog(CKPT_LOG_ERROR, "Wrong program image file (%lu != %lu)", header.mtime, ckptElfGetMtime());
        abort();
    }

    if (brk((void *)header.brk) != 0)
    {
        ckptLog(CKPT_LOG_ERROR, "Unable to set new break @%p", header.brk);
        abort();
    }
    *stack_start = (void *)header.stack_start;

    return 1;
}
Beispiel #26
0
void PowerON_Reset_PC(void)
{ 
	set_intb((void*)__sectop("C$VECT"));
//	set_fpsw(FPSW_init);

	_INITSCT();

//	_INIT_IOLIB();					// Remove the comment when you use SIM I/O

//	errno=0;						// Remove the comment when you use errno
//	srand((_UINT)1);				// Remove the comment when you use rand()
//	_s1ptr=NULL;					// Remove the comment when you use strtok()
		
//	HardwareSetup();				// Use Hardware Setup
    nop();

//	_CALL_INIT();					// Remove the comment when you use global class object

	set_psw(PSW_init);				// Set Ubit & Ibit for PSW
//	Change_PSW_PM_to_UserMode();	// DO NOT CHANGE TO USER MODE IF USING FREERTOS!
	( void ) Change_PSW_PM_to_UserMode; // Just to avoid compiler warnings.

	main();

//	_CLOSEALL();					// Use SIM I/O
	
//	_CALL_END();					// Remove the comment when you use global class object

	brk();
}
Beispiel #27
0
void    _free(void *ptr)
{
    t_block *block;

    RETURN(!ptr || ptr > LAST_PTR() || ptr < FIRST_PTR());
    block = GET_BLOCK(ptr);
    RETURN(block->isFree);
    block->isFree = true;
    if (block->parent == last && last->startBlock == last->lastBlock)
    {
        if (!(last = last->prev))
            blocks = NULL;
        else
            last->next = NULL;
        brk(block->parent);
    }
    else if (block == block->parent->lastBlock)
    {
        if (!(block->parent->lastBlock = block->prev))
            block->parent->startBlock = NULL;
        block->parent->freeSize += B_SIZE(block->size);
    }
    else if (block->parent->maxFreeSize < block->size)
        block->parent->maxFreeSize = block->size;
}
Beispiel #28
0
static struct memh *brkmore(size_t nb)
{
	struct memh *p;

	if (nb < BRKSIZE)
		nb = BRKSIZE;

	/* Here be dragons: sbrk takes a signed value. We can however in C malloc
	   a size_t: We also assume nobody else misaligns the brk boundary, we won't
	   fix it if so - maybe we should ? */

	/* Current end of memory */
	p = sbrk(0);
	if (p == (struct memh *) -1)
		return NULL;
	/* Overflow catch */
	if (p + nb < p)
		return NULL;
	/* Move our break point. Using brk this way avoids the sign problems */
	if (brk(p + nb))
		return NULL;
	/* Fake it as a used block and free it into the free list */
	p->size = nb;
	free(p + 1);
	return __mfreeptr;
}
void PowerON_Reset_PC(void)
{
#ifdef __RXV2
    set_extb(__sectop("EXCEPTVECT"));
#endif
    set_intb(__sectop("C$VECT"));

#ifdef __ROZ                        /* Initialize FPSW */
#define _ROUND 0x00000001           /* Let FPSW RMbits=01 (round to zero) */
#else
#define _ROUND 0x00000000           /* Let FPSW RMbits=00 (round to nearest) */
#endif
#ifdef __DOFF
#define _DENOM 0x00000100           /* Let FPSW DNbit=1 (denormal as zero) */
#else
#define _DENOM 0x00000000           /* Let FPSW DNbit=0 (denormal as is) */
#endif

    set_fpsw(FPSW_init | _ROUND | _DENOM);

    _INITSCT();                     /* Initialize Sections */
    HardwareSetup();                /* Use Hardware Setup */
    nop();
    set_psw(PSW_init);              /* Set Ubit & Ibit for PSW */
    main();
    brk();
}
Beispiel #30
0
static void sbrk_test(void)
{
#if defined(__s390__) && __WORDSIZE == 32
	void *ret1, *ret2;

	/* set bkr to 0x10000000 */
	tst_res(TINFO, "initial brk: %d", brk((void *)0x10000000));

	/* add 0x10000000, up to total of 0x20000000 */
	tst_res(TINFO, "sbrk increm: %p", sbrk(0x10000000));
	ret1 = sbrk(0);

	/* sbrk() returns -1 on s390, but still does overflowed brk() */
	tst_res(TINFO, "sbrk increm: %p", sbrk(0x70000000));
	ret2 = sbrk(0);

	if (ret1 != ret2) {
		tst_res(TFAIL, "Bug! sbrk: %p", ret2);
		return;
	}

	tst_res(TPASS, "sbrk verify: %p", ret2);
#else
	tst_res(TCONF, "Only works in 32bit on s390 series system");
#endif
}