powerpc: Enable lockup and hung task detectors in pseries and ppc64 defeconfigs
[linux-2.6.git] / arch / powerpc / lib / rheap.c
1 /*
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
6  * endianess.
7  *
8  * Author: Pantelis Antoniou <panto@intracom.gr>
9  *
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
13  * or implied.
14  */
15 #include <linux/types.h>
16 #include <linux/errno.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/mm.h>
20 #include <linux/err.h>
21 #include <linux/slab.h>
22
23 #include <asm/rheap.h>
24
25 /*
26  * Fixup a list_head, needed when copying lists.  If the pointers fall
27  * between s and e, apply the delta.  This assumes that
28  * sizeof(struct list_head *) == sizeof(unsigned long *).
29  */
30 static inline void fixup(unsigned long s, unsigned long e, int d,
31                          struct list_head *l)
32 {
33         unsigned long *pp;
34
35         pp = (unsigned long *)&l->next;
36         if (*pp >= s && *pp < e)
37                 *pp += d;
38
39         pp = (unsigned long *)&l->prev;
40         if (*pp >= s && *pp < e)
41                 *pp += d;
42 }
43
44 /* Grow the allocated blocks */
45 static int grow(rh_info_t * info, int max_blocks)
46 {
47         rh_block_t *block, *blk;
48         int i, new_blocks;
49         int delta;
50         unsigned long blks, blke;
51
52         if (max_blocks <= info->max_blocks)
53                 return -EINVAL;
54
55         new_blocks = max_blocks - info->max_blocks;
56
57         block = kmalloc(sizeof(rh_block_t) * max_blocks, GFP_ATOMIC);
58         if (block == NULL)
59                 return -ENOMEM;
60
61         if (info->max_blocks > 0) {
62
63                 /* copy old block area */
64                 memcpy(block, info->block,
65                        sizeof(rh_block_t) * info->max_blocks);
66
67                 delta = (char *)block - (char *)info->block;
68
69                 /* and fixup list pointers */
70                 blks = (unsigned long)info->block;
71                 blke = (unsigned long)(info->block + info->max_blocks);
72
73                 for (i = 0, blk = block; i < info->max_blocks; i++, blk++)
74                         fixup(blks, blke, delta, &blk->list);
75
76                 fixup(blks, blke, delta, &info->empty_list);
77                 fixup(blks, blke, delta, &info->free_list);
78                 fixup(blks, blke, delta, &info->taken_list);
79
80                 /* free the old allocated memory */
81                 if ((info->flags & RHIF_STATIC_BLOCK) == 0)
82                         kfree(info->block);
83         }
84
85         info->block = block;
86         info->empty_slots += new_blocks;
87         info->max_blocks = max_blocks;
88         info->flags &= ~RHIF_STATIC_BLOCK;
89
90         /* add all new blocks to the free list */
91         blk = block + info->max_blocks - new_blocks;
92         for (i = 0; i < new_blocks; i++, blk++)
93                 list_add(&blk->list, &info->empty_list);
94
95         return 0;
96 }
97
98 /*
99  * Assure at least the required amount of empty slots.  If this function
100  * causes a grow in the block area then all pointers kept to the block
101  * area are invalid!
102  */
103 static int assure_empty(rh_info_t * info, int slots)
104 {
105         int max_blocks;
106
107         /* This function is not meant to be used to grow uncontrollably */
108         if (slots >= 4)
109                 return -EINVAL;
110
111         /* Enough space */
112         if (info->empty_slots >= slots)
113                 return 0;
114
115         /* Next 16 sized block */
116         max_blocks = ((info->max_blocks + slots) + 15) & ~15;
117
118         return grow(info, max_blocks);
119 }
120
121 static rh_block_t *get_slot(rh_info_t * info)
122 {
123         rh_block_t *blk;
124
125         /* If no more free slots, and failure to extend. */
126         /* XXX: You should have called assure_empty before */
127         if (info->empty_slots == 0) {
128                 printk(KERN_ERR "rh: out of slots; crash is imminent.\n");
129                 return NULL;
130         }
131
132         /* Get empty slot to use */
133         blk = list_entry(info->empty_list.next, rh_block_t, list);
134         list_del_init(&blk->list);
135         info->empty_slots--;
136
137         /* Initialize */
138         blk->start = 0;
139         blk->size = 0;
140         blk->owner = NULL;
141
142         return blk;
143 }
144
145 static inline void release_slot(rh_info_t * info, rh_block_t * blk)
146 {
147         list_add(&blk->list, &info->empty_list);
148         info->empty_slots++;
149 }
150
151 static void attach_free_block(rh_info_t * info, rh_block_t * blkn)
152 {
153         rh_block_t *blk;
154         rh_block_t *before;
155         rh_block_t *after;
156         rh_block_t *next;
157         int size;
158         unsigned long s, e, bs, be;
159         struct list_head *l;
160
161         /* We assume that they are aligned properly */
162         size = blkn->size;
163         s = blkn->start;
164         e = s + size;
165
166         /* Find the blocks immediately before and after the given one
167          * (if any) */
168         before = NULL;
169         after = NULL;
170         next = NULL;
171
172         list_for_each(l, &info->free_list) {
173                 blk = list_entry(l, rh_block_t, list);
174
175                 bs = blk->start;
176                 be = bs + blk->size;
177
178                 if (next == NULL && s >= bs)
179                         next = blk;
180
181                 if (be == s)
182                         before = blk;
183
184                 if (e == bs)
185                         after = blk;
186
187                 /* If both are not null, break now */
188                 if (before != NULL && after != NULL)
189                         break;
190         }
191
192         /* Now check if they are really adjacent */
193         if (before && s != (before->start + before->size))
194                 before = NULL;
195
196         if (after && e != after->start)
197                 after = NULL;
198
199         /* No coalescing; list insert and return */
200         if (before == NULL && after == NULL) {
201
202                 if (next != NULL)
203                         list_add(&blkn->list, &next->list);
204                 else
205                         list_add(&blkn->list, &info->free_list);
206
207                 return;
208         }
209
210         /* We don't need it anymore */
211         release_slot(info, blkn);
212
213         /* Grow the before block */
214         if (before != NULL && after == NULL) {
215                 before->size += size;
216                 return;
217         }
218
219         /* Grow the after block backwards */
220         if (before == NULL && after != NULL) {
221                 after->start -= size;
222                 after->size += size;
223                 return;
224         }
225
226         /* Grow the before block, and release the after block */
227         before->size += size + after->size;
228         list_del(&after->list);
229         release_slot(info, after);
230 }
231
232 static void attach_taken_block(rh_info_t * info, rh_block_t * blkn)
233 {
234         rh_block_t *blk;
235         struct list_head *l;
236
237         /* Find the block immediately before the given one (if any) */
238         list_for_each(l, &info->taken_list) {
239                 blk = list_entry(l, rh_block_t, list);
240                 if (blk->start > blkn->start) {
241                         list_add_tail(&blkn->list, &blk->list);
242                         return;
243                 }
244         }
245
246         list_add_tail(&blkn->list, &info->taken_list);
247 }
248
249 /*
250  * Create a remote heap dynamically.  Note that no memory for the blocks
251  * are allocated.  It will upon the first allocation
252  */
253 rh_info_t *rh_create(unsigned int alignment)
254 {
255         rh_info_t *info;
256
257         /* Alignment must be a power of two */
258         if ((alignment & (alignment - 1)) != 0)
259                 return ERR_PTR(-EINVAL);
260
261         info = kmalloc(sizeof(*info), GFP_ATOMIC);
262         if (info == NULL)
263                 return ERR_PTR(-ENOMEM);
264
265         info->alignment = alignment;
266
267         /* Initially everything as empty */
268         info->block = NULL;
269         info->max_blocks = 0;
270         info->empty_slots = 0;
271         info->flags = 0;
272
273         INIT_LIST_HEAD(&info->empty_list);
274         INIT_LIST_HEAD(&info->free_list);
275         INIT_LIST_HEAD(&info->taken_list);
276
277         return info;
278 }
279 EXPORT_SYMBOL_GPL(rh_create);
280
281 /*
282  * Destroy a dynamically created remote heap.  Deallocate only if the areas
283  * are not static
284  */
285 void rh_destroy(rh_info_t * info)
286 {
287         if ((info->flags & RHIF_STATIC_BLOCK) == 0 && info->block != NULL)
288                 kfree(info->block);
289
290         if ((info->flags & RHIF_STATIC_INFO) == 0)
291                 kfree(info);
292 }
293 EXPORT_SYMBOL_GPL(rh_destroy);
294
295 /*
296  * Initialize in place a remote heap info block.  This is needed to support
297  * operation very early in the startup of the kernel, when it is not yet safe
298  * to call kmalloc.
299  */
300 void rh_init(rh_info_t * info, unsigned int alignment, int max_blocks,
301              rh_block_t * block)
302 {
303         int i;
304         rh_block_t *blk;
305
306         /* Alignment must be a power of two */
307         if ((alignment & (alignment - 1)) != 0)
308                 return;
309
310         info->alignment = alignment;
311
312         /* Initially everything as empty */
313         info->block = block;
314         info->max_blocks = max_blocks;
315         info->empty_slots = max_blocks;
316         info->flags = RHIF_STATIC_INFO | RHIF_STATIC_BLOCK;
317
318         INIT_LIST_HEAD(&info->empty_list);
319         INIT_LIST_HEAD(&info->free_list);
320         INIT_LIST_HEAD(&info->taken_list);
321
322         /* Add all new blocks to the free list */
323         for (i = 0, blk = block; i < max_blocks; i++, blk++)
324                 list_add(&blk->list, &info->empty_list);
325 }
326 EXPORT_SYMBOL_GPL(rh_init);
327
328 /* Attach a free memory region, coalesces regions if adjuscent */
329 int rh_attach_region(rh_info_t * info, unsigned long start, int size)
330 {
331         rh_block_t *blk;
332         unsigned long s, e, m;
333         int r;
334
335         /* The region must be aligned */
336         s = start;
337         e = s + size;
338         m = info->alignment - 1;
339
340         /* Round start up */
341         s = (s + m) & ~m;
342
343         /* Round end down */
344         e = e & ~m;
345
346         if (IS_ERR_VALUE(e) || (e < s))
347                 return -ERANGE;
348
349         /* Take final values */
350         start = s;
351         size = e - s;
352
353         /* Grow the blocks, if needed */
354         r = assure_empty(info, 1);
355         if (r < 0)
356                 return r;
357
358         blk = get_slot(info);
359         blk->start = start;
360         blk->size = size;
361         blk->owner = NULL;
362
363         attach_free_block(info, blk);
364
365         return 0;
366 }
367 EXPORT_SYMBOL_GPL(rh_attach_region);
368
369 /* Detatch given address range, splits free block if needed. */
370 unsigned long rh_detach_region(rh_info_t * info, unsigned long start, int size)
371 {
372         struct list_head *l;
373         rh_block_t *blk, *newblk;
374         unsigned long s, e, m, bs, be;
375
376         /* Validate size */
377         if (size <= 0)
378                 return (unsigned long) -EINVAL;
379
380         /* The region must be aligned */
381         s = start;
382         e = s + size;
383         m = info->alignment - 1;
384
385         /* Round start up */
386         s = (s + m) & ~m;
387
388         /* Round end down */
389         e = e & ~m;
390
391         if (assure_empty(info, 1) < 0)
392                 return (unsigned long) -ENOMEM;
393
394         blk = NULL;
395         list_for_each(l, &info->free_list) {
396                 blk = list_entry(l, rh_block_t, list);
397                 /* The range must lie entirely inside one free block */
398                 bs = blk->start;
399                 be = blk->start + blk->size;
400                 if (s >= bs && e <= be)
401                         break;
402                 blk = NULL;
403         }
404
405         if (blk == NULL)
406                 return (unsigned long) -ENOMEM;
407
408         /* Perfect fit */
409         if (bs == s && be == e) {
410                 /* Delete from free list, release slot */
411                 list_del(&blk->list);
412                 release_slot(info, blk);
413                 return s;
414         }
415
416         /* blk still in free list, with updated start and/or size */
417         if (bs == s || be == e) {
418                 if (bs == s)
419                         blk->start += size;
420                 blk->size -= size;
421
422         } else {
423                 /* The front free fragment */
424                 blk->size = s - bs;
425
426                 /* the back free fragment */
427                 newblk = get_slot(info);
428                 newblk->start = e;
429                 newblk->size = be - e;
430
431                 list_add(&newblk->list, &blk->list);
432         }
433
434         return s;
435 }
436 EXPORT_SYMBOL_GPL(rh_detach_region);
437
438 /* Allocate a block of memory at the specified alignment.  The value returned
439  * is an offset into the buffer initialized by rh_init(), or a negative number
440  * if there is an error.
441  */
442 unsigned long rh_alloc_align(rh_info_t * info, int size, int alignment, const char *owner)
443 {
444         struct list_head *l;
445         rh_block_t *blk;
446         rh_block_t *newblk;
447         unsigned long start, sp_size;
448
449         /* Validate size, and alignment must be power of two */
450         if (size <= 0 || (alignment & (alignment - 1)) != 0)
451                 return (unsigned long) -EINVAL;
452
453         /* Align to configured alignment */
454         size = (size + (info->alignment - 1)) & ~(info->alignment - 1);
455
456         if (assure_empty(info, 2) < 0)
457                 return (unsigned long) -ENOMEM;
458
459         blk = NULL;
460         list_for_each(l, &info->free_list) {
461                 blk = list_entry(l, rh_block_t, list);
462                 if (size <= blk->size) {
463                         start = (blk->start + alignment - 1) & ~(alignment - 1);
464                         if (start + size <= blk->start + blk->size)
465                                 break;
466                 }
467                 blk = NULL;
468         }
469
470         if (blk == NULL)
471                 return (unsigned long) -ENOMEM;
472
473         /* Just fits */
474         if (blk->size == size) {
475                 /* Move from free list to taken list */
476                 list_del(&blk->list);
477                 newblk = blk;
478         } else {
479                 /* Fragment caused, split if needed */
480                 /* Create block for fragment in the beginning */
481                 sp_size = start - blk->start;
482                 if (sp_size) {
483                         rh_block_t *spblk;
484
485                         spblk = get_slot(info);
486                         spblk->start = blk->start;
487                         spblk->size = sp_size;
488                         /* add before the blk */
489                         list_add(&spblk->list, blk->list.prev);
490                 }
491                 newblk = get_slot(info);
492                 newblk->start = start;
493                 newblk->size = size;
494
495                 /* blk still in free list, with updated start and size
496                  * for fragment in the end */
497                 blk->start = start + size;
498                 blk->size -= sp_size + size;
499                 /* No fragment in the end, remove blk */
500                 if (blk->size == 0) {
501                         list_del(&blk->list);
502                         release_slot(info, blk);
503                 }
504         }
505
506         newblk->owner = owner;
507         attach_taken_block(info, newblk);
508
509         return start;
510 }
511 EXPORT_SYMBOL_GPL(rh_alloc_align);
512
513 /* Allocate a block of memory at the default alignment.  The value returned is
514  * an offset into the buffer initialized by rh_init(), or a negative number if
515  * there is an error.
516  */
517 unsigned long rh_alloc(rh_info_t * info, int size, const char *owner)
518 {
519         return rh_alloc_align(info, size, info->alignment, owner);
520 }
521 EXPORT_SYMBOL_GPL(rh_alloc);
522
523 /* Allocate a block of memory at the given offset, rounded up to the default
524  * alignment.  The value returned is an offset into the buffer initialized by
525  * rh_init(), or a negative number if there is an error.
526  */
527 unsigned long rh_alloc_fixed(rh_info_t * info, unsigned long start, int size, const char *owner)
528 {
529         struct list_head *l;
530         rh_block_t *blk, *newblk1, *newblk2;
531         unsigned long s, e, m, bs = 0, be = 0;
532
533         /* Validate size */
534         if (size <= 0)
535                 return (unsigned long) -EINVAL;
536
537         /* The region must be aligned */
538         s = start;
539         e = s + size;
540         m = info->alignment - 1;
541
542         /* Round start up */
543         s = (s + m) & ~m;
544
545         /* Round end down */
546         e = e & ~m;
547
548         if (assure_empty(info, 2) < 0)
549                 return (unsigned long) -ENOMEM;
550
551         blk = NULL;
552         list_for_each(l, &info->free_list) {
553                 blk = list_entry(l, rh_block_t, list);
554                 /* The range must lie entirely inside one free block */
555                 bs = blk->start;
556                 be = blk->start + blk->size;
557                 if (s >= bs && e <= be)
558                         break;
559                 blk = NULL;
560         }
561
562         if (blk == NULL)
563                 return (unsigned long) -ENOMEM;
564
565         /* Perfect fit */
566         if (bs == s && be == e) {
567                 /* Move from free list to taken list */
568                 list_del(&blk->list);
569                 blk->owner = owner;
570
571                 start = blk->start;
572                 attach_taken_block(info, blk);
573
574                 return start;
575
576         }
577
578         /* blk still in free list, with updated start and/or size */
579         if (bs == s || be == e) {
580                 if (bs == s)
581                         blk->start += size;
582                 blk->size -= size;
583
584         } else {
585                 /* The front free fragment */
586                 blk->size = s - bs;
587
588                 /* The back free fragment */
589                 newblk2 = get_slot(info);
590                 newblk2->start = e;
591                 newblk2->size = be - e;
592
593                 list_add(&newblk2->list, &blk->list);
594         }
595
596         newblk1 = get_slot(info);
597         newblk1->start = s;
598         newblk1->size = e - s;
599         newblk1->owner = owner;
600
601         start = newblk1->start;
602         attach_taken_block(info, newblk1);
603
604         return start;
605 }
606 EXPORT_SYMBOL_GPL(rh_alloc_fixed);
607
608 /* Deallocate the memory previously allocated by one of the rh_alloc functions.
609  * The return value is the size of the deallocated block, or a negative number
610  * if there is an error.
611  */
612 int rh_free(rh_info_t * info, unsigned long start)
613 {
614         rh_block_t *blk, *blk2;
615         struct list_head *l;
616         int size;
617
618         /* Linear search for block */
619         blk = NULL;
620         list_for_each(l, &info->taken_list) {
621                 blk2 = list_entry(l, rh_block_t, list);
622                 if (start < blk2->start)
623                         break;
624                 blk = blk2;
625         }
626
627         if (blk == NULL || start > (blk->start + blk->size))
628                 return -EINVAL;
629
630         /* Remove from taken list */
631         list_del(&blk->list);
632
633         /* Get size of freed block */
634         size = blk->size;
635         attach_free_block(info, blk);
636
637         return size;
638 }
639 EXPORT_SYMBOL_GPL(rh_free);
640
641 int rh_get_stats(rh_info_t * info, int what, int max_stats, rh_stats_t * stats)
642 {
643         rh_block_t *blk;
644         struct list_head *l;
645         struct list_head *h;
646         int nr;
647
648         switch (what) {
649
650         case RHGS_FREE:
651                 h = &info->free_list;
652                 break;
653
654         case RHGS_TAKEN:
655                 h = &info->taken_list;
656                 break;
657
658         default:
659                 return -EINVAL;
660         }
661
662         /* Linear search for block */
663         nr = 0;
664         list_for_each(l, h) {
665                 blk = list_entry(l, rh_block_t, list);
666                 if (stats != NULL && nr < max_stats) {
667                         stats->start = blk->start;
668                         stats->size = blk->size;
669                         stats->owner = blk->owner;
670                         stats++;
671                 }
672                 nr++;
673         }
674
675         return nr;
676 }
677 EXPORT_SYMBOL_GPL(rh_get_stats);
678
679 int rh_set_owner(rh_info_t * info, unsigned long start, const char *owner)
680 {
681         rh_block_t *blk, *blk2;
682         struct list_head *l;
683         int size;
684
685         /* Linear search for block */
686         blk = NULL;
687         list_for_each(l, &info->taken_list) {
688                 blk2 = list_entry(l, rh_block_t, list);
689                 if (start < blk2->start)
690                         break;
691                 blk = blk2;
692         }
693
694         if (blk == NULL || start > (blk->start + blk->size))
695                 return -EINVAL;
696
697         blk->owner = owner;
698         size = blk->size;
699
700         return size;
701 }
702 EXPORT_SYMBOL_GPL(rh_set_owner);
703
704 void rh_dump(rh_info_t * info)
705 {
706         static rh_stats_t st[32];       /* XXX maximum 32 blocks */
707         int maxnr;
708         int i, nr;
709
710         maxnr = ARRAY_SIZE(st);
711
712         printk(KERN_INFO
713                "info @0x%p (%d slots empty / %d max)\n",
714                info, info->empty_slots, info->max_blocks);
715
716         printk(KERN_INFO "  Free:\n");
717         nr = rh_get_stats(info, RHGS_FREE, maxnr, st);
718         if (nr > maxnr)
719                 nr = maxnr;
720         for (i = 0; i < nr; i++)
721                 printk(KERN_INFO
722                        "    0x%lx-0x%lx (%u)\n",
723                        st[i].start, st[i].start + st[i].size,
724                        st[i].size);
725         printk(KERN_INFO "\n");
726
727         printk(KERN_INFO "  Taken:\n");
728         nr = rh_get_stats(info, RHGS_TAKEN, maxnr, st);
729         if (nr > maxnr)
730                 nr = maxnr;
731         for (i = 0; i < nr; i++)
732                 printk(KERN_INFO
733                        "    0x%lx-0x%lx (%u) %s\n",
734                        st[i].start, st[i].start + st[i].size,
735                        st[i].size, st[i].owner != NULL ? st[i].owner : "");
736         printk(KERN_INFO "\n");
737 }
738 EXPORT_SYMBOL_GPL(rh_dump);
739
740 void rh_dump_blk(rh_info_t * info, rh_block_t * blk)
741 {
742         printk(KERN_INFO
743                "blk @0x%p: 0x%lx-0x%lx (%u)\n",
744                blk, blk->start, blk->start + blk->size, blk->size);
745 }
746 EXPORT_SYMBOL_GPL(rh_dump_blk);
747