#include <sys/mman.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "utils.h"

Macros
#define	foreach_arg(_arg, _addr, _len, _first_addr, _first_len)

#define	C_PTR_ALIGN (sizeof(size_t))

#define	C_PTR_MASK (-C_PTR_ALIGN)

#define	MAP_ANONYMOUS MAP_ANON

Functions
void *	__calloc_a (size_t len,...)

void *	cbuf_alloc (unsigned int order)

void	cbuf_free (void *ptr, unsigned int order)

int	mkdir_p (char *dir, mode_t mask)

Macro Definition Documentation

◆ C_PTR_ALIGN

#define C_PTR_ALIGN (sizeof(size_t))

Definition at line 32 of file utils.c.

◆ C_PTR_MASK

#define C_PTR_MASK (-C_PTR_ALIGN)

Definition at line 33 of file utils.c.

◆ foreach_arg

#define foreach_arg	(	_arg,
		_addr,
		_len,
		_first_addr,
		_first_len
	)

Value:

        for (_addr = (_first_addr), _len = (_first_len); \
                _addr; \
                _addr = va_arg(_arg, void **), _len = _addr ? va_arg(_arg, size_t) : 0)

Definition at line 27 of file utils.c.

◆ MAP_ANONYMOUS

#define MAP_ANONYMOUS MAP_ANON

Function Documentation

◆ __calloc_a()

void* __calloc_a	(	size_t	len,
			...
	)

Definition at line 35 of file utils.c.

 {
         va_list ap, ap1;
         void *ret;
         void **cur_addr;
         size_t cur_len;
         int alloc_len = 0;
         char *ptr;
  
         va_start(ap, len);
  
         va_copy(ap1, ap);
         foreach_arg(ap1, cur_addr, cur_len, &ret, len)
                 alloc_len += (cur_len + C_PTR_ALIGN - 1 ) & C_PTR_MASK;
         va_end(ap1);
  
         ptr = calloc(1, alloc_len);
         if (!ptr) {
                 va_end(ap);
                 return NULL;
         }
  
         alloc_len = 0;
         foreach_arg(ap, cur_addr, cur_len, &ret, len) {
                 *cur_addr = &ptr[alloc_len];
                 alloc_len += (cur_len + C_PTR_ALIGN - 1) & C_PTR_MASK;
         }
         va_end(ap);
  
         return ret;
 }

◆ cbuf_alloc()

void* cbuf_alloc ( unsigned int order )

Definition at line 116 of file utils.c.

 {
         char path[] = "/tmp/cbuf-XXXXXX";
         unsigned long size = cbuf_size(order);
         void *ret = NULL;
         int fd;
  
         fd = mkstemp(path);
         if (fd < 0)
                 return NULL;
  
         if (unlink(path))
                 goto close;
  
         if (ftruncate(fd, cbuf_size(order)))
                 goto close;
  
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
  
         ret = mmap(NULL, size * 2, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
         if (ret == MAP_FAILED) {
                 ret = NULL;
                 goto close;
         }
  
         if (mmap(ret, size, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED,
                  fd, 0) != ret ||
             mmap(ret + size, size, PROT_READ | PROT_WRITE,
                  MAP_FIXED | MAP_SHARED, fd, 0) != ret + size) {
                 munmap(ret, size * 2);
                 ret = NULL;
         }
  
 close:
         close(fd);
         return ret;
 }

Here is the call graph for this function:

◆ cbuf_free()

void cbuf_free	(	void *	ptr,
		unsigned int	order
	)

Definition at line 156 of file utils.c.

 {
         munmap(ptr, cbuf_size(order) * 2);
 }