workbench/devs/diskimage/plugins/cue/malloc.c

   1 /* Copyright 2007-2012 Fredrik Wikstrom. All rights reserved.
   2 **
   3 ** Redistribution and use in source and binary forms, with or without
   4 ** modification, are permitted provided that the following conditions
   5 ** are met:
   6 **
   7 ** 1. Redistributions of source code must retain the above copyright
   8 **    notice, this list of conditions and the following disclaimer.
   9 **
  10 ** 2. Redistributions in binary form must reproduce the above copyright
  11 **    notice, this list of conditions and the following disclaimer in the
  12 **    documentation and/or other materials provided with the distribution.
  13 **
  14 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
  15 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  18 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  19 ** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  20 ** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  21 ** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  22 ** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  23 ** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  24 ** POSSIBILITY OF SUCH DAMAGE.
  25 */
  26
  27 #include <proto/exec.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include "support.h"
  31
  32 extern struct Library *SysBase;
  33
  34 #define MIN(a,b) ((a)<=(b)?(a):(b))
  35 #define BASE_PTR(ptr) ((void *)((size_t *)ptr - 1))
  36 #define ALLOC_SIZE(ptr) (*((size_t *)ptr - 1))
  37
  38 static struct SignalSemaphore *LibPoolSemaphore;
  39 static APTR LibPool;
  40
  41 int malloc_init(void) {
  42         if ((LibPoolSemaphore = CreateSemaphore())) {
  43                 if ((LibPool = CreatePool(MEMF_ANY, 4096, 1024))) {
  44                         return TRUE;
  45                 }
  46                 DeleteSemaphore(LibPoolSemaphore);
  47         }
  48         return FALSE;
  49 }
  50
  51 void malloc_exit(void) {
  52         DeletePool(LibPool);
  53         DeleteSemaphore(LibPoolSemaphore);
  54 }
  55
  56 void *malloc(size_t size) {
  57         size_t *ptr;
  58         ObtainSemaphore(LibPoolSemaphore);
  59         ptr = AllocPooled(LibPool, sizeof(size_t) + size);
  60         ReleaseSemaphore(LibPoolSemaphore);
  61         if (ptr) {
  62                 *ptr++ = size;
  63         }
  64         return ptr;
  65 }
  66
  67 void *realloc(void *old, size_t size) {
  68         if (old) {
  69                 size_t old_size = ALLOC_SIZE(old);
  70                 void *new;
  71                 if (size == old_size) {
  72                         return old;
  73                 }
  74                 if ((new = malloc(size))) {
  75                         memcpy(new, old, MIN(size, old_size));
  76                         free(old);
  77                         return new;
  78                 }
  79                 free(old);
  80                 return NULL;
  81         } else {
  82                 return malloc(size);
  83         }
  84 }
  85
  86 void free(void *ptr) {
  87         if (ptr) {
  88                 ObtainSemaphore(LibPoolSemaphore);
  89                 FreePooled(LibPool, BASE_PTR(ptr), sizeof(size_t) + ALLOC_SIZE(ptr));
  90                 ReleaseSemaphore(LibPoolSemaphore);
  91         }
  92 }
  93
  94 void *calloc(size_t num, size_t size) {
  95         void *ptr;
  96         size *= num;
  97         if ((ptr = malloc(size))) {
  98                 memset(ptr, 0, size);
  99         }
 100         return ptr;
 101 }