safe_alloc.h

Go to the documentation of this file.

/*
 * CDDL HEADER START
 *
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2023 Saso Kiselkov. All rights reserved.
 */
#ifndef _ACF_UTILS_SAFE_ALLOC_H_
#define _ACF_UTILS_SAFE_ALLOC_H_
 
#include <errno.h>
#include <string.h>
#include <stdlib.h>
 
#if IBM
#include <malloc.h>
#endif
 
#if defined(__cplusplus) && __cplusplus >= 201703L
#include <cstdlib>
#endif
 
#include "assert.h"
#include "sysmacros.h"
 
#ifdef  __cplusplus
extern "C" {
#endif
 
static inline void *
safe_malloc(size_t size)
{
    void *p = malloc(size);
    if (size > 0) {
        VERIFY_MSG(p != NULL, "Cannot allocate %lu bytes: "
            "out of memory", (long unsigned)size);
    }
    return (p);
}
 
static inline void *
safe_calloc(size_t nmemb, size_t size)
{
    void *p = calloc(nmemb, size);
    if (nmemb > 0 && size > 0) {
        VERIFY_MSG(p != NULL, "Cannot allocate %lu bytes: "
            "out of memory", (long unsigned)(nmemb * size));
    }
    return (p);
}
 
static inline void *
safe_realloc(void *oldptr, size_t size)
{
    void *p = realloc(oldptr, size);
    if (size > 0) {
        VERIFY_MSG(p != NULL, "Cannot allocate %lu bytes: "
            "out of memory", (long unsigned)size);
    }
    return (p);
}
 
#if !APL || __MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_15
#if IBM || __STDC_VERSION__ >= 201112L || __cplusplus >= 201703L || \
    _POSIX_C_SOURCE >= 200112L || defined(__DOXYGEN__)
 
static inline void *
safe_aligned_malloc(size_t alignment, size_t size)
{
    void *p = NULL;
    int err = 0;
    ASSERT3U(alignment, >=, sizeof (void *));
    ASSERT0(alignment ^ (1 << highbit64(alignment)));
#if IBM
    p = _aligned_malloc(size, alignment);
    if (size > 0 && p == NULL)
        err = ENOMEM;
#elif   __STDC_VERSION__ >= 201112L
    p = aligned_alloc(alignment, size);
    if (size > 0 && p == NULL)
        err = ENOMEM;
#elif   __cplusplus >= 201703L
    p = std::aligned_alloc(alignment, size);
    if (size > 0 && p == NULL)
        err = ENOMEM;
#elif   defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L
    err = posix_memalign(&p, alignment, size);
#else   /* !(__STDC_VERSION__ >= 201112L || _POSIX_C_SOURCE >= 200112L) */
    VERIFY_FAIL();
#endif  /* !(__STDC_VERSION__ >= 201112L || _POSIX_C_SOURCE >= 200112L) */
    VERIFY_MSG(err == 0, "Cannot allocate %lu bytes (align %lu): %s",
        (long unsigned)size, (long unsigned)alignment, strerror(err));
 
    return (p);
}
 
static inline void *
safe_aligned_calloc(size_t alignment, size_t nmemb, size_t size)
{
    void *p = safe_aligned_malloc(alignment, nmemb * size);
    memset(p, 0, size);
    return (p);
}
 
static inline void
aligned_free(void *ptr)
{
#if IBM
    _aligned_free(ptr);
#else
    free(ptr);
#endif
}
 
#endif \
/* __STDC_VERSION__ || __cplusplus || IBM || _POSIX_C_SOURCE || __DOXYGEN__ */
 
#endif  /* !APL || CMAKE_OSX_DEPLOYMENT_TARGET >= MAC_OS_X_VERSION_10_15 */
 
static inline char *
safe_strdup(const char *str2)
{
    char *str;
    size_t l;
    ASSERT(str2 != NULL);
    l = strlen(str2);
    str = (char *)safe_malloc(l + 1);
    memcpy(str, str2, l);
    str[l] = '\0';
    return (str);
}
 
static inline char *
safe_append_realloc(char *buf, const char *str)
{
    char *newbuf;
 
    ASSERT(str != NULL);
    if (buf == NULL)
        return (safe_strdup(str));
    newbuf = (char *)safe_realloc(buf, strlen(buf) + strlen(str) + 1);
    memcpy(&newbuf[strlen(newbuf)], str, strlen(str) + 1);
    return (newbuf);
}
 
#define ZERO_FREE(ptr) \
    do { \
        NOT_TYPE_ASSERT(ptr, void *); \
        NOT_TYPE_ASSERT(ptr, char *); \
        if ((ptr) != NULL) \
            memset((ptr), 0, sizeof (*(ptr))); \
        free(ptr); \
    } while (0)
#define DESTROY_FREE(ptr) \
    do { \
        ZERO_FREE(ptr); \
        (ptr) = NULL; \
    } while (0)
 
#define ZERO_FREE_N(ptr, num) \
    do { \
        NOT_TYPE_ASSERT(ptr, void *); \
        if ((ptr) != NULL) \
            memset((ptr), 0, sizeof (*(ptr)) * (num)); \
        free(ptr); \
    } while (0)
#define DESTROY_FREE_N(ptr, num) \
    do { \
        ZERO_FREE_N((ptr), (num)); \
        (ptr) = NULL; \
    while (0)
 
#define BZERO(data) memset((data), 0, sizeof (*(data)))
 
#define SAFE_BZERO(data) \
    do { \
        if ((data) != NULL) \
            BZERO(data); \
    } while (0)
 
#ifdef  __cplusplus
}
#endif
 
#endif  /* _ACF_UTILS_SAFE_ALLOC_H_ */