2 * A Remote Heap. Remote means that we don't touch the memory that the
3 * heap points to. Normal heap implementations use the memory they manage
4 * to place their list. We cannot do that because the memory we manage may
5 * have special properties, for example it is uncachable or of different
8 * Author: Pantelis Antoniou <panto@intracom.gr>
10 * 2004 (c) INTRACOM S.A. Greece. This file is licensed under
11 * the terms of the GNU General Public License version 2. This program
12 * is licensed "as is" without any warranty of any kind, whether express
15 #include <linux/types.h>
16 #include <linux/errno.h>
17 #include <linux/kernel.h>
19 #include <linux/slab.h>
21 #include <asm/rheap.h>
24 * Fixup a list_head, needed when copying lists. If the pointers fall
25 * between s and e, apply the delta. This assumes that
26 * sizeof(struct list_head *) == sizeof(unsigned long *).
28 static inline void fixup(unsigned long s
, unsigned long e
, int d
,
33 pp
= (unsigned long *)&l
->next
;
34 if (*pp
>= s
&& *pp
< e
)
37 pp
= (unsigned long *)&l
->prev
;
38 if (*pp
>= s
&& *pp
< e
)
42 /* Grow the allocated blocks */
43 static int grow(rh_info_t
* info
, int max_blocks
)
45 rh_block_t
*block
, *blk
;
48 unsigned long blks
, blke
;
50 if (max_blocks
<= info
->max_blocks
)
53 new_blocks
= max_blocks
- info
->max_blocks
;
55 block
= kmalloc(sizeof(rh_block_t
) * max_blocks
, GFP_KERNEL
);
59 if (info
->max_blocks
> 0) {
61 /* copy old block area */
62 memcpy(block
, info
->block
,
63 sizeof(rh_block_t
) * info
->max_blocks
);
65 delta
= (char *)block
- (char *)info
->block
;
67 /* and fixup list pointers */
68 blks
= (unsigned long)info
->block
;
69 blke
= (unsigned long)(info
->block
+ info
->max_blocks
);
71 for (i
= 0, blk
= block
; i
< info
->max_blocks
; i
++, blk
++)
72 fixup(blks
, blke
, delta
, &blk
->list
);
74 fixup(blks
, blke
, delta
, &info
->empty_list
);
75 fixup(blks
, blke
, delta
, &info
->free_list
);
76 fixup(blks
, blke
, delta
, &info
->taken_list
);
78 /* free the old allocated memory */
79 if ((info
->flags
& RHIF_STATIC_BLOCK
) == 0)
84 info
->empty_slots
+= new_blocks
;
85 info
->max_blocks
= max_blocks
;
86 info
->flags
&= ~RHIF_STATIC_BLOCK
;
88 /* add all new blocks to the free list */
89 blk
= block
+ info
->max_blocks
- new_blocks
;
90 for (i
= 0; i
< new_blocks
; i
++, blk
++)
91 list_add(&blk
->list
, &info
->empty_list
);
97 * Assure at least the required amount of empty slots. If this function
98 * causes a grow in the block area then all pointers kept to the block
101 static int assure_empty(rh_info_t
* info
, int slots
)
105 /* This function is not meant to be used to grow uncontrollably */
110 if (info
->empty_slots
>= slots
)
113 /* Next 16 sized block */
114 max_blocks
= ((info
->max_blocks
+ slots
) + 15) & ~15;
116 return grow(info
, max_blocks
);
119 static rh_block_t
*get_slot(rh_info_t
* info
)
123 /* If no more free slots, and failure to extend. */
124 /* XXX: You should have called assure_empty before */
125 if (info
->empty_slots
== 0) {
126 printk(KERN_ERR
"rh: out of slots; crash is imminent.\n");
130 /* Get empty slot to use */
131 blk
= list_entry(info
->empty_list
.next
, rh_block_t
, list
);
132 list_del_init(&blk
->list
);
143 static inline void release_slot(rh_info_t
* info
, rh_block_t
* blk
)
145 list_add(&blk
->list
, &info
->empty_list
);
149 static void attach_free_block(rh_info_t
* info
, rh_block_t
* blkn
)
156 unsigned long s
, e
, bs
, be
;
159 /* We assume that they are aligned properly */
161 s
= (unsigned long)blkn
->start
;
164 /* Find the blocks immediately before and after the given one
170 list_for_each(l
, &info
->free_list
) {
171 blk
= list_entry(l
, rh_block_t
, list
);
173 bs
= (unsigned long)blk
->start
;
176 if (next
== NULL
&& s
>= bs
)
185 /* If both are not null, break now */
186 if (before
!= NULL
&& after
!= NULL
)
190 /* Now check if they are really adjacent */
191 if (before
!= NULL
&& s
!= (unsigned long)before
->start
+ before
->size
)
194 if (after
!= NULL
&& e
!= (unsigned long)after
->start
)
197 /* No coalescing; list insert and return */
198 if (before
== NULL
&& after
== NULL
) {
201 list_add(&blkn
->list
, &next
->list
);
203 list_add(&blkn
->list
, &info
->free_list
);
208 /* We don't need it anymore */
209 release_slot(info
, blkn
);
211 /* Grow the before block */
212 if (before
!= NULL
&& after
== NULL
) {
213 before
->size
+= size
;
217 /* Grow the after block backwards */
218 if (before
== NULL
&& after
!= NULL
) {
219 after
->start
= (int8_t *)after
->start
- size
;
224 /* Grow the before block, and release the after block */
225 before
->size
+= size
+ after
->size
;
226 list_del(&after
->list
);
227 release_slot(info
, after
);
230 static void attach_taken_block(rh_info_t
* info
, rh_block_t
* blkn
)
235 /* Find the block immediately before the given one (if any) */
236 list_for_each(l
, &info
->taken_list
) {
237 blk
= list_entry(l
, rh_block_t
, list
);
238 if (blk
->start
> blkn
->start
) {
239 list_add_tail(&blkn
->list
, &blk
->list
);
244 list_add_tail(&blkn
->list
, &info
->taken_list
);
248 * Create a remote heap dynamically. Note that no memory for the blocks
249 * are allocated. It will upon the first allocation
251 rh_info_t
*rh_create(unsigned int alignment
)
255 /* Alignment must be a power of two */
256 if ((alignment
& (alignment
- 1)) != 0)
257 return ERR_PTR(-EINVAL
);
259 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
261 return ERR_PTR(-ENOMEM
);
263 info
->alignment
= alignment
;
265 /* Initially everything as empty */
267 info
->max_blocks
= 0;
268 info
->empty_slots
= 0;
271 INIT_LIST_HEAD(&info
->empty_list
);
272 INIT_LIST_HEAD(&info
->free_list
);
273 INIT_LIST_HEAD(&info
->taken_list
);
279 * Destroy a dynamically created remote heap. Deallocate only if the areas
282 void rh_destroy(rh_info_t
* info
)
284 if ((info
->flags
& RHIF_STATIC_BLOCK
) == 0 && info
->block
!= NULL
)
287 if ((info
->flags
& RHIF_STATIC_INFO
) == 0)
292 * Initialize in place a remote heap info block. This is needed to support
293 * operation very early in the startup of the kernel, when it is not yet safe
296 void rh_init(rh_info_t
* info
, unsigned int alignment
, int max_blocks
,
302 /* Alignment must be a power of two */
303 if ((alignment
& (alignment
- 1)) != 0)
306 info
->alignment
= alignment
;
308 /* Initially everything as empty */
310 info
->max_blocks
= max_blocks
;
311 info
->empty_slots
= max_blocks
;
312 info
->flags
= RHIF_STATIC_INFO
| RHIF_STATIC_BLOCK
;
314 INIT_LIST_HEAD(&info
->empty_list
);
315 INIT_LIST_HEAD(&info
->free_list
);
316 INIT_LIST_HEAD(&info
->taken_list
);
318 /* Add all new blocks to the free list */
319 for (i
= 0, blk
= block
; i
< max_blocks
; i
++, blk
++)
320 list_add(&blk
->list
, &info
->empty_list
);
323 /* Attach a free memory region, coalesces regions if adjuscent */
324 int rh_attach_region(rh_info_t
* info
, void *start
, int size
)
327 unsigned long s
, e
, m
;
330 /* The region must be aligned */
331 s
= (unsigned long)start
;
333 m
= info
->alignment
- 1;
341 /* Take final values */
345 /* Grow the blocks, if needed */
346 r
= assure_empty(info
, 1);
350 blk
= get_slot(info
);
355 attach_free_block(info
, blk
);
360 /* Detatch given address range, splits free block if needed. */
361 void *rh_detach_region(rh_info_t
* info
, void *start
, int size
)
364 rh_block_t
*blk
, *newblk
;
365 unsigned long s
, e
, m
, bs
, be
;
369 return ERR_PTR(-EINVAL
);
371 /* The region must be aligned */
372 s
= (unsigned long)start
;
374 m
= info
->alignment
- 1;
382 if (assure_empty(info
, 1) < 0)
383 return ERR_PTR(-ENOMEM
);
386 list_for_each(l
, &info
->free_list
) {
387 blk
= list_entry(l
, rh_block_t
, list
);
388 /* The range must lie entirely inside one free block */
389 bs
= (unsigned long)blk
->start
;
390 be
= (unsigned long)blk
->start
+ blk
->size
;
391 if (s
>= bs
&& e
<= be
)
397 return ERR_PTR(-ENOMEM
);
400 if (bs
== s
&& be
== e
) {
401 /* Delete from free list, release slot */
402 list_del(&blk
->list
);
403 release_slot(info
, blk
);
407 /* blk still in free list, with updated start and/or size */
408 if (bs
== s
|| be
== e
) {
410 blk
->start
= (int8_t *)blk
->start
+ size
;
414 /* The front free fragment */
417 /* the back free fragment */
418 newblk
= get_slot(info
);
419 newblk
->start
= (void *)e
;
420 newblk
->size
= be
- e
;
422 list_add(&newblk
->list
, &blk
->list
);
428 void *rh_alloc_align(rh_info_t
* info
, int size
, int alignment
, const char *owner
)
435 /* Validate size, (must be power of two) */
436 if (size
<= 0 || (alignment
& (alignment
- 1)) != 0)
437 return ERR_PTR(-EINVAL
);
439 /* given alignment larger that default rheap alignment */
440 if (alignment
> info
->alignment
)
441 size
+= alignment
- 1;
443 /* Align to configured alignment */
444 size
= (size
+ (info
->alignment
- 1)) & ~(info
->alignment
- 1);
446 if (assure_empty(info
, 1) < 0)
447 return ERR_PTR(-ENOMEM
);
450 list_for_each(l
, &info
->free_list
) {
451 blk
= list_entry(l
, rh_block_t
, list
);
452 if (size
<= blk
->size
)
458 return ERR_PTR(-ENOMEM
);
461 if (blk
->size
== size
) {
462 /* Move from free list to taken list */
463 list_del(&blk
->list
);
467 attach_taken_block(info
, blk
);
472 newblk
= get_slot(info
);
473 newblk
->start
= blk
->start
;
475 newblk
->owner
= owner
;
477 /* blk still in free list, with updated start, size */
478 blk
->start
= (int8_t *)blk
->start
+ size
;
481 start
= newblk
->start
;
483 attach_taken_block(info
, newblk
);
485 /* for larger alignment return fixed up pointer */
486 /* this is no problem with the deallocator since */
487 /* we scan for pointers that lie in the blocks */
488 if (alignment
> info
->alignment
)
489 start
= (void *)(((unsigned long)start
+ alignment
- 1) &
495 void *rh_alloc(rh_info_t
* info
, int size
, const char *owner
)
497 return rh_alloc_align(info
, size
, info
->alignment
, owner
);
500 /* allocate at precisely the given address */
501 void *rh_alloc_fixed(rh_info_t
* info
, void *start
, int size
, const char *owner
)
504 rh_block_t
*blk
, *newblk1
, *newblk2
;
505 unsigned long s
, e
, m
, bs
= 0, be
= 0;
509 return ERR_PTR(-EINVAL
);
511 /* The region must be aligned */
512 s
= (unsigned long)start
;
514 m
= info
->alignment
- 1;
522 if (assure_empty(info
, 2) < 0)
523 return ERR_PTR(-ENOMEM
);
526 list_for_each(l
, &info
->free_list
) {
527 blk
= list_entry(l
, rh_block_t
, list
);
528 /* The range must lie entirely inside one free block */
529 bs
= (unsigned long)blk
->start
;
530 be
= (unsigned long)blk
->start
+ blk
->size
;
531 if (s
>= bs
&& e
<= be
)
536 return ERR_PTR(-ENOMEM
);
539 if (bs
== s
&& be
== e
) {
540 /* Move from free list to taken list */
541 list_del(&blk
->list
);
545 attach_taken_block(info
, blk
);
551 /* blk still in free list, with updated start and/or size */
552 if (bs
== s
|| be
== e
) {
554 blk
->start
= (int8_t *)blk
->start
+ size
;
558 /* The front free fragment */
561 /* The back free fragment */
562 newblk2
= get_slot(info
);
563 newblk2
->start
= (void *)e
;
564 newblk2
->size
= be
- e
;
566 list_add(&newblk2
->list
, &blk
->list
);
569 newblk1
= get_slot(info
);
570 newblk1
->start
= (void *)s
;
571 newblk1
->size
= e
- s
;
572 newblk1
->owner
= owner
;
574 start
= newblk1
->start
;
575 attach_taken_block(info
, newblk1
);
580 int rh_free(rh_info_t
* info
, void *start
)
582 rh_block_t
*blk
, *blk2
;
586 /* Linear search for block */
588 list_for_each(l
, &info
->taken_list
) {
589 blk2
= list_entry(l
, rh_block_t
, list
);
590 if (start
< blk2
->start
)
595 if (blk
== NULL
|| start
> (blk
->start
+ blk
->size
))
598 /* Remove from taken list */
599 list_del(&blk
->list
);
601 /* Get size of freed block */
603 attach_free_block(info
, blk
);
608 int rh_get_stats(rh_info_t
* info
, int what
, int max_stats
, rh_stats_t
* stats
)
618 h
= &info
->free_list
;
622 h
= &info
->taken_list
;
629 /* Linear search for block */
631 list_for_each(l
, h
) {
632 blk
= list_entry(l
, rh_block_t
, list
);
633 if (stats
!= NULL
&& nr
< max_stats
) {
634 stats
->start
= blk
->start
;
635 stats
->size
= blk
->size
;
636 stats
->owner
= blk
->owner
;
645 int rh_set_owner(rh_info_t
* info
, void *start
, const char *owner
)
647 rh_block_t
*blk
, *blk2
;
651 /* Linear search for block */
653 list_for_each(l
, &info
->taken_list
) {
654 blk2
= list_entry(l
, rh_block_t
, list
);
655 if (start
< blk2
->start
)
660 if (blk
== NULL
|| start
> (blk
->start
+ blk
->size
))
669 void rh_dump(rh_info_t
* info
)
671 static rh_stats_t st
[32]; /* XXX maximum 32 blocks */
675 maxnr
= ARRAY_SIZE(st
);
678 "info @0x%p (%d slots empty / %d max)\n",
679 info
, info
->empty_slots
, info
->max_blocks
);
681 printk(KERN_INFO
" Free:\n");
682 nr
= rh_get_stats(info
, RHGS_FREE
, maxnr
, st
);
685 for (i
= 0; i
< nr
; i
++)
688 st
[i
].start
, (int8_t *) st
[i
].start
+ st
[i
].size
,
690 printk(KERN_INFO
"\n");
692 printk(KERN_INFO
" Taken:\n");
693 nr
= rh_get_stats(info
, RHGS_TAKEN
, maxnr
, st
);
696 for (i
= 0; i
< nr
; i
++)
698 " 0x%p-0x%p (%u) %s\n",
699 st
[i
].start
, (int8_t *) st
[i
].start
+ st
[i
].size
,
700 st
[i
].size
, st
[i
].owner
!= NULL
? st
[i
].owner
: "");
701 printk(KERN_INFO
"\n");
704 void rh_dump_blk(rh_info_t
* info
, rh_block_t
* blk
)
707 "blk @0x%p: 0x%p-0x%p (%u)\n",
708 blk
, blk
->start
, (int8_t *) blk
->start
+ blk
->size
, blk
->size
);