alloc.h

Go to the documentation of this file.

/*
 * util/alloc.h - memory allocation service. 
 *
 * Copyright (c) 2007, NLnet Labs. All rights reserved.
 *
 * This software is open source.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * 
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 * 
 * Neither the name of the NLNET LABS nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef UTIL_ALLOC_H
#define UTIL_ALLOC_H
 
#include "util/locks.h"
struct ub_packed_rrset_key;
struct regional;
 
typedef struct ub_packed_rrset_key alloc_special_type;
#define alloc_special_clean(x) (x)->id = 0;
#define alloc_special_next(x) ((alloc_special_type*)((x)->entry.overflow_next))
#define alloc_set_special_next(x, y) \
    ((x)->entry.overflow_next) = (struct lruhash_entry*)(y);
 
#define ALLOC_SPECIAL_MAX 10
 
struct alloc_cache {
    lock_quick_type lock;
    struct alloc_cache* super;
    alloc_special_type* quar;
    size_t num_quar;
    int thread_num;
    uint64_t next_id;
    uint64_t last_id;
    void (*cleanup)(void*);
    void* cleanup_arg;
 
    size_t max_reg_blocks;
    size_t num_reg_blocks;
    struct regional* reg_list;
};
 
void alloc_init(struct alloc_cache* alloc, struct alloc_cache* super,
    int thread_num);
 
void alloc_clear(struct alloc_cache* alloc);
 
void alloc_clear_special(struct alloc_cache* alloc);
 
alloc_special_type* alloc_special_obtain(struct alloc_cache* alloc);
 
void alloc_special_release(struct alloc_cache* alloc, alloc_special_type* mem);
 
uint64_t alloc_get_id(struct alloc_cache* alloc);
 
size_t alloc_get_mem(struct alloc_cache* alloc);
 
void alloc_stats(struct alloc_cache* alloc);
 
struct regional* alloc_reg_obtain(struct alloc_cache* alloc);
 
void alloc_reg_release(struct alloc_cache* alloc, struct regional* r);
 
void alloc_set_id_cleanup(struct alloc_cache* alloc, void (*cleanup)(void*),
    void* arg);
 
#ifdef UNBOUND_ALLOC_LITE
#  include <sldns/ldns.h>
#  include <sldns/packet.h>
#  ifdef HAVE_OPENSSL_SSL_H
#    include <openssl/ssl.h>
#  endif
#  define malloc(s) unbound_stat_malloc_lite(s, __FILE__, __LINE__, __func__)
#  define calloc(n,s) unbound_stat_calloc_lite(n, s, __FILE__, __LINE__, __func__)
#  define free(p) unbound_stat_free_lite(p, __FILE__, __LINE__, __func__)
#  define realloc(p,s) unbound_stat_realloc_lite(p, s, __FILE__, __LINE__, __func__)
void *unbound_stat_malloc_lite(size_t size, const char* file, int line,
    const char* func);
void *unbound_stat_calloc_lite(size_t nmemb, size_t size, const char* file,
    int line, const char* func);
void unbound_stat_free_lite(void *ptr, const char* file, int line,
    const char* func);
void *unbound_stat_realloc_lite(void *ptr, size_t size, const char* file,
    int line, const char* func);
#  ifdef strdup
#    undef strdup
#  endif
#  define strdup(s) unbound_strdup_lite(s, __FILE__, __LINE__, __func__)
char* unbound_strdup_lite(const char* s, const char* file, int line, 
    const char* func);
char* unbound_lite_wrapstr(char* s);
#  define sldns_rr2str(rr) unbound_lite_wrapstr(sldns_rr2str(rr))
#  define sldns_rdf2str(rdf) unbound_lite_wrapstr(sldns_rdf2str(rdf))
#  define sldns_rr_type2str(t) unbound_lite_wrapstr(sldns_rr_type2str(t))
#  define sldns_rr_class2str(c) unbound_lite_wrapstr(sldns_rr_class2str(c))
#  define sldns_rr_list2str(r) unbound_lite_wrapstr(sldns_rr_list2str(r))
#  define sldns_pkt2str(p) unbound_lite_wrapstr(sldns_pkt2str(p))
#  define sldns_pkt_rcode2str(r) unbound_lite_wrapstr(sldns_pkt_rcode2str(r))
#  define sldns_pkt2wire(a, r, s) unbound_lite_pkt2wire(a, r, s)
sldns_status unbound_lite_pkt2wire(uint8_t **dest, const sldns_pkt *p, size_t *size);
#  define i2d_DSA_SIG(d, s) unbound_lite_i2d_DSA_SIG(d, s)
int unbound_lite_i2d_DSA_SIG(DSA_SIG* dsasig, unsigned char** sig);
#endif /* UNBOUND_ALLOC_LITE */
 
#endif /* UTIL_ALLOC_H */