LCOV - code coverage report
Current view: top level - src/interfaces/ecpg/ecpglib - memory.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 60 70 85.7 %
Date: 2019-08-24 15:07:19 Functions: 12 12 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* src/interfaces/ecpg/ecpglib/memory.c */
       2             : 
       3             : #define POSTGRES_ECPG_INTERNAL
       4             : #include "postgres_fe.h"
       5             : 
       6             : #include "ecpg-pthread-win32.h"
       7             : #include "ecpgtype.h"
       8             : #include "ecpglib.h"
       9             : #include "ecpgerrno.h"
      10             : #include "ecpglib_extern.h"
      11             : 
      12             : void
      13      523540 : ecpg_free(void *ptr)
      14             : {
      15      523540 :     free(ptr);
      16      523540 : }
      17             : 
      18             : char *
      19      466060 : ecpg_alloc(long size, int lineno)
      20             : {
      21      466060 :     char       *new = (char *) calloc(1L, size);
      22             : 
      23      466060 :     if (!new)
      24             :     {
      25           0 :         ecpg_raise(lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
      26           0 :         return NULL;
      27             :     }
      28             : 
      29      466060 :     return new;
      30             : }
      31             : 
      32             : char *
      33       21240 : ecpg_realloc(void *ptr, long size, int lineno)
      34             : {
      35       21240 :     char       *new = (char *) realloc(ptr, size);
      36             : 
      37       21240 :     if (!new)
      38             :     {
      39           0 :         ecpg_raise(lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
      40           0 :         return NULL;
      41             :     }
      42             : 
      43       21240 :     return new;
      44             : }
      45             : 
      46             : char *
      47       22564 : ecpg_strdup(const char *string, int lineno)
      48             : {
      49             :     char       *new;
      50             : 
      51       22564 :     if (string == NULL)
      52           2 :         return NULL;
      53             : 
      54       22562 :     new = strdup(string);
      55       22562 :     if (!new)
      56             :     {
      57           0 :         ecpg_raise(lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
      58           0 :         return NULL;
      59             :     }
      60             : 
      61       22562 :     return new;
      62             : }
      63             : 
      64             : /* keep a list of memory we allocated for the user */
      65             : struct auto_mem
      66             : {
      67             :     void       *pointer;
      68             :     struct auto_mem *next;
      69             : };
      70             : 
      71             : #ifdef ENABLE_THREAD_SAFETY
      72             : static pthread_key_t auto_mem_key;
      73             : static pthread_once_t auto_mem_once = PTHREAD_ONCE_INIT;
      74             : 
      75             : static void
      76          64 : auto_mem_destructor(void *arg)
      77             : {
      78             :     (void) arg;                 /* keep the compiler quiet */
      79          64 :     ECPGfree_auto_mem();
      80          64 : }
      81             : 
      82             : static void
      83         222 : auto_mem_key_init(void)
      84             : {
      85         222 :     pthread_key_create(&auto_mem_key, auto_mem_destructor);
      86         222 : }
      87             : 
      88             : static struct auto_mem *
      89       14628 : get_auto_allocs(void)
      90             : {
      91       14628 :     pthread_once(&auto_mem_once, auto_mem_key_init);
      92       14634 :     return (struct auto_mem *) pthread_getspecific(auto_mem_key);
      93             : }
      94             : 
      95             : static void
      96        6508 : set_auto_allocs(struct auto_mem *am)
      97             : {
      98        6508 :     pthread_setspecific(auto_mem_key, am);
      99        6508 : }
     100             : #else
     101             : static struct auto_mem *auto_allocs = NULL;
     102             : 
     103             : #define get_auto_allocs()       (auto_allocs)
     104             : #define set_auto_allocs(am)     do { auto_allocs = (am); } while(0)
     105             : #endif
     106             : 
     107             : char *
     108        3336 : ecpg_auto_alloc(long size, int lineno)
     109             : {
     110        3336 :     void       *ptr = (void *) ecpg_alloc(size, lineno);
     111             : 
     112        3336 :     if (!ptr)
     113           0 :         return NULL;
     114             : 
     115        3336 :     if (!ecpg_add_mem(ptr, lineno))
     116             :     {
     117           0 :         ecpg_free(ptr);
     118           0 :         return NULL;
     119             :     }
     120        3336 :     return ptr;
     121             : }
     122             : 
     123             : bool
     124        3336 : ecpg_add_mem(void *ptr, int lineno)
     125             : {
     126        3336 :     struct auto_mem *am = (struct auto_mem *) ecpg_alloc(sizeof(struct auto_mem), lineno);
     127             : 
     128        3336 :     if (!am)
     129           0 :         return false;
     130             : 
     131        3336 :     am->pointer = ptr;
     132        3336 :     am->next = get_auto_allocs();
     133        3336 :     set_auto_allocs(am);
     134        3336 :     return true;
     135             : }
     136             : 
     137             : void
     138         298 : ECPGfree_auto_mem(void)
     139             : {
     140         298 :     struct auto_mem *am = get_auto_allocs();
     141             : 
     142             :     /* free all memory we have allocated for the user */
     143         298 :     if (am)
     144             :     {
     145             :         do
     146             :         {
     147          80 :             struct auto_mem *act = am;
     148             : 
     149          80 :             am = am->next;
     150          80 :             ecpg_free(act->pointer);
     151          80 :             ecpg_free(act);
     152          80 :         } while (am);
     153           8 :         set_auto_allocs(NULL);
     154             :     }
     155         298 : }
     156             : 
     157             : void
     158       10994 : ecpg_clear_auto_mem(void)
     159             : {
     160       10994 :     struct auto_mem *am = get_auto_allocs();
     161             : 
     162             :     /* only free our own structure */
     163       11000 :     if (am)
     164             :     {
     165             :         do
     166             :         {
     167        3164 :             struct auto_mem *act = am;
     168             : 
     169        3164 :             am = am->next;
     170        3164 :             ecpg_free(act);
     171        3164 :         } while (am);
     172        3164 :         set_auto_allocs(NULL);
     173             :     }
     174       11000 : }

Generated by: LCOV version 1.13