Subversion Repositories Kolibri OS

Rev

Rev 817 | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 817 Rev 829
Line 40... Line 40...
40 
 */
 40 
 */
Line 41... Line 41...
41 
 
 41 
 
42 
struct mem_block {
 42 
struct mem_block {
43 
	struct mem_block *next;
 43 
	struct mem_block *next;
44 
	struct mem_block *prev;
 44 
	struct mem_block *prev;
45 
	int start;
 45 
  u32_t  start;
46 
	int size;
 46 
  size_t size;
Line 47... Line 47...
47 
};
 47 
};
48 
 
 48 
 
49 
/* Initialize.  How to check for an uninitialized heap?
 49 
/* Initialize.  How to check for an uninitialized heap?
50 
 */
 50 
 */
51 
static int init_heap(struct mem_block **heap, int start, int size)
 51 
static int init_heap(struct mem_block **heap, int start, int size)
Line 52... Line 52...
52 
{
 52 
{
53 
  struct mem_block *blocks = kmalloc(sizeof(*blocks));
 53 
  struct mem_block *blocks = malloc(sizeof(*blocks));
Line 54... Line 54...
54 
 
 54 
 
55 
	if (!blocks)
 55 
	if (!blocks)
56 
    return -1; //-ENOMEM;
 56 
    return -1; //-ENOMEM;
57 
 
 57 
 
58 
  *heap = kmalloc(sizeof(**heap));
 58 
  *heap = malloc(sizeof(**heap));
59 
  if (!*heap)
 59 
  if (!*heap)
Line 60... Line 60...
60 
  {
 60 
  {
61 
    kfree(blocks);
 61 
    free(blocks);
62 
    return -1; //-ENOMEM;
 62 
    return -1; //-ENOMEM;
Line 63... Line 63...
63 
	}
 63 
	}
64 
 
 64 
 
- 
 
 65 
  blocks->start = start;
65 
  blocks->start = start;
 66 
  blocks->size  = size;
66 
  blocks->size  = size;
 67 
  blocks->next  = blocks->prev = *heap;
Line 67... Line 68...
67 
  blocks->next  = blocks->prev = *heap;
 68 
 
68 
 
 69 
  __clear(*heap,sizeof(**heap));
Line 88... Line 89...
88 
{
 89 
{
Line 89... Line 90...
89 
 
 90 
 
90 
	/* Maybe cut off the end of an existing block */
 91 
	/* Maybe cut off the end of an existing block */
91 
    if (size < p->size)
 92 
    if (size < p->size)
92 
    {
 93 
    {
93 
      struct mem_block *newblock = kmalloc(sizeof(*newblock));
 94 
      struct mem_block *newblock = malloc(sizeof(*newblock));
94 
      if (!newblock)
 95 
      if (!newblock)
95 
        goto out;
 96 
        goto out;
96 
      newblock->start = p->start + size;
 97 
      newblock->start = p->start + size;
97 
      newblock->size = p->size - size;
 98 
      newblock->size = p->size - size;
98 
      newblock->next = p->next;
 99 
      newblock->next = p->next;
99 
      newblock->prev = p;
 100 
      newblock->prev = p;
100 
      p->next->prev = newblock;
 101 
      p->next->prev = newblock;
101 
      p->next = newblock;
 102 
      p->next = newblock;
102 
      p->size = size;
 103 
      p->size = size;
103 
      p->start|=1;
 104 
      p->start|=USED_BLOCK;
Line 104... Line 105...
104 
    }
 105 
    }
105 
 
 106 
 
106 
out:
 107 
out:
Line 111... Line 112...
111 
{
 112 
{
112 
	struct mem_block *p;
 113 
	struct mem_block *p;
Line 113... Line 114...
113 
 
 114 
 
114 
  list_for_each(p, heap)
 115 
  list_for_each(p, heap)
- 
 
 116 
  {
115 
  {
 117 
 
116 
    if ( !(p->start & USED_BLOCK) && size <= p->size)
 118 
    if ( !(p->start & USED_BLOCK) && size <= p->size)
117 
      return split_block(p, size);
 119 
      return split_block(p, size);
Line 118... Line 120...
118 
	}
 120 
	}
Line 126... Line 128...
126 
	struct mem_block *p;
 128 
	struct mem_block *p;
Line 127... Line 129...
127 
 
 129 
 
128 
	list_for_each(p, heap)
 130 
	list_for_each(p, heap)
129 
    if ((p->start & ~USED_BLOCK) == start)
 131 
    if ((p->start & ~USED_BLOCK) == start)
130 
			return p;
 - 
 
131 
 
 132 
			return p;
132 
	return NULL;
 133 
	return NULL;
Line 133... Line 134...
133 
}
 134 
}
134 
 
 135 
 
Line 145... Line 146...
145 
  {
 146 
  {
146 
		struct mem_block *q = p->next;
 147 
		struct mem_block *q = p->next;
147 
		p->size += q->size;
 148 
		p->size += q->size;
148 
		p->next = q->next;
 149 
		p->next = q->next;
149 
		p->next->prev = p;
 150 
		p->next->prev = p;
150 
    kfree(q);
 151 
    free(q);
151 
	}
 152 
	}
Line 152... Line 153...
152 
 
 153 
 
153 
  if ( !(p->prev->start & USED_BLOCK))
 154 
  if ( !(p->prev->start & USED_BLOCK))
154 
  {
 155 
  {
155 
		struct mem_block *q = p->prev;
 156 
		struct mem_block *q = p->prev;
156 
		q->size += p->size;
 157 
		q->size += p->size;
157 
		q->next = p->next;
 158 
		q->next = p->next;
158 
		q->next->prev = q;
 159 
		q->next->prev = q;
159 
    kfree(p);
 160 
    free(p);
160 
	}
 161 
	}
Line 161... Line 162...
161 
}
 162 
}
162 
 
 163 
 
Line 199... Line 200...
199 
 
 200 
 
200 
  block = find_block(*heap, (int)offset);
 201 
  block = find_block(*heap, (int)offset);
201 
	if (!block)
 202 
	if (!block)
Line 202... Line 203...
202 
    return -1;
 203 
    return -1;
203 
 
 204 
 
Line 204... Line 205...
204 
  if ( !(block->start & 1))
 205 
  if ( !(block->start & USED_BLOCK))
205 
    return -1;
 206 
    return -1;
206 
 
 207 
 
Line -... Line 208...
- 
 
 208 
	free_block(block);
- 
 
 209 
	return 0;
- 
 
 210 
}
- 
 
 211 
 
- 
 
 212 
void dump_mem()
- 
 
 213 
{
- 
 
 214 
	struct mem_block *p;
- 
 
 215 
  struct mem_block **heap;
- 
 
 216 
 
- 
 
 217 
  heap = &rhd.fb_heap;
- 
 
 218 
 
- 
 
 219 
  list_for_each(p, *heap)
- 
 
 220 
  {