Line data    Source code

       1             : /*
       2             :  * alloc.c
       3             :  *
       4             :  * memory allocation and deallocation 
       5             :  *
       6             :  * David A. McGrew
       7             :  * Cisco Systems, Inc.
       8             :  */
       9             : /*
      10             :  *      
      11             :  * Copyright (c) 2001-2006 Cisco Systems, Inc.
      12             :  * All rights reserved.
      13             :  * 
      14             :  * Redistribution and use in source and binary forms, with or without
      15             :  * modification, are permitted provided that the following conditions
      16             :  * are met:
      17             :  * 
      18             :  *   Redistributions of source code must retain the above copyright
      19             :  *   notice, this list of conditions and the following disclaimer.
      20             :  * 
      21             :  *   Redistributions in binary form must reproduce the above
      22             :  *   copyright notice, this list of conditions and the following
      23             :  *   disclaimer in the documentation and/or other materials provided
      24             :  *   with the distribution.
      25             :  * 
      26             :  *   Neither the name of the Cisco Systems, Inc. nor the names of its
      27             :  *   contributors may be used to endorse or promote products derived
      28             :  *   from this software without specific prior written permission.
      29             :  * 
      30             :  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      31             :  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      32             :  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
      33             :  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
      34             :  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
      35             :  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
      36             :  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
      37             :  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      38             :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
      39             :  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
      40             :  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
      41             :  * OF THE POSSIBILITY OF SUCH DAMAGE.
      42             :  *
      43             :  */
      44             : 
      45             : #include "alloc.h"
      46             : #include "crypto_kernel.h"
      47             : 
      48             : /* the debug module for memory allocation */
      49             : 
      50             : debug_module_t mod_alloc = {
      51             :   0,                  /* debugging is off by default */
      52             :   "alloc"             /* printable name for module   */
      53             : };
      54             : 
      55             : /*
      56             :  * Nota bene: the debugging statements for crypto_alloc() and
      57             :  * crypto_free() have identical prefixes, which include the addresses
      58             :  * of the memory locations on which they are operating.  This fact can
      59             :  * be used to locate memory leaks, by turning on memory debugging,
      60             :  * grepping for 'alloc', then matching alloc and free calls by
      61             :  * address.
      62             :  */
      63             : 
      64             : #ifdef SRTP_KERNEL_LINUX
      65             : 
      66             : #include <linux/interrupt.h>
      67             : 
      68             : void *
      69             : crypto_alloc(size_t size) {
      70             :   void *ptr;
      71             : 
      72             :   ptr = kmalloc(size, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
      73             : 
      74             :   if (ptr) {
      75             :     debug_print(mod_alloc, "(location: %p) allocated", ptr);
      76             :   } else {
      77             :     debug_print(mod_alloc, "allocation failed (asked for %d bytes)\n", size);
      78             :   }
      79             : 
      80             :   return ptr;
      81             : }
      82             : 
      83             : void 
      84             : crypto_free(void *ptr) {
      85             : 
      86             :   debug_print(mod_alloc, "(location: %p) freed", ptr);
      87             : 
      88             :   kfree(ptr);
      89             : }
      90             : 
      91             : 
      92             : #elif defined(HAVE_STDLIB_H)
      93             : 
      94             : void *
      95           0 : crypto_alloc(size_t size) {
      96             :   void *ptr;
      97             : 
      98           0 :   ptr = malloc(size);
      99             :     
     100             :   if (ptr) {
     101             :     debug_print(mod_alloc, "(location: %p) allocated", ptr);
     102             :   } else {
     103             :     debug_print(mod_alloc, "allocation failed (asked for %d bytes)\n", size);
     104             :   }
     105             :     
     106           0 :   return ptr;
     107             : }
     108             : 
     109             : void 
     110           0 : crypto_free(void *ptr) {
     111             : 
     112             :   debug_print(mod_alloc, "(location: %p) freed", ptr);
     113             : 
     114           0 :   free(ptr);
     115           0 : }
     116             : 
     117             : #else  /* we need to define our own memory allocation routines */
     118             : 
     119             : #error no memory allocation defined yet 
     120             : 
     121             : #endif