/usr/share/systemtap/runtime/dyninst/ Current File: //usr/share/systemtap/runtime/dyninst/shm.c
/* -*- linux-c -*-
 * Shared Memory Functions
 * Copyright (C) 2012 Red Hat Inc.
 *
 * This file is part of systemtap, and is free software.  You can
 * redistribute it and/or modify it under the terms of the GNU General
 * Public License (GPL); either version 2, or (at your option) any
 * later version.
 */

#ifndef _STAPDYN_SHM_H_
#define _STAPDYN_SHM_H_

#include <fcntl.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

static char _stp_shm_name[NAME_MAX] = { '\0' };
static int _stp_shm_fd = -1;
static int _stp_shm_page_size = -1;
static off_t _stp_shm_size = 0;
static off_t _stp_shm_allocated = 0;
static void *_stp_shm_base = NULL;

static const char *_stp_shm_init(void);
static int _stp_shm_connect(const char *name);
static void *_stp_shm_alloc(size_t size);
static void *_stp_shm_zalloc(size_t size);
static void _stp_shm_free(void *ptr);
static void _stp_shm_finalize(void);
static void _stp_shm_destroy(void);


#ifdef DEBUG_SHM
#define shm_dbug(fmt, args...) _stp_dbug(__FUNCTION__, __LINE__, fmt, ##args)
#else
#define shm_dbug(fmt, args...)
#endif


// Create and initialize the shared memory for this module.
static const char *_stp_shm_init(void)
{
	char name[NAME_MAX];
	long page_size;
	int fd;
	void *base;

	// If we already have shared memory, carry on...
	if (_stp_shm_base)
		return _stp_shm_name;

	// Find the increment to use in growing our memory size.  Since this is
	// used in mmap, only multiples of the page size make sense.
	page_size = sysconf(_SC_PAGESIZE);
	if (page_size < 1)
		return NULL;

	// Create a unique name for our shared memory.  It need not be anything
        // secret because shm_open's flags will ensure security.
        (void) snprintf(name, NAME_MAX, "/stapdyn.%d", getpid());

	// Create the actual share memory.  The O_EXCL saves us from the
	// possible mktemp race.  Only USR file mode bits are added, because
	// that's all that ptrace will allow to attach anyway.  (Unless you're
	// root, but that deserves much larger consideration.)
	fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
	if (fd < 0)
		return NULL;

	// Start the shared memory sized with just one unit.
	if (ftruncate(fd, page_size) < 0)
		goto err_fd;

	// Now finally map it into this process.
	base = mmap(NULL, page_size, PROT_READ | PROT_WRITE,
		    MAP_SHARED, fd, 0);
	if (base == MAP_FAILED)
		goto err_fd;

	// We're done; set globals and go home!
	strlcpy(_stp_shm_name, name, sizeof(_stp_shm_name));
	_stp_shm_fd = fd;
	_stp_shm_page_size = page_size;
	_stp_shm_size = page_size;
	_stp_shm_allocated = 0;
	_stp_shm_base = base;
	shm_dbug("initialized %s @ %p", _stp_shm_name, _stp_shm_base);
	return _stp_shm_name;

err_fd:
	close(fd);
	shm_unlink(_stp_shm_name);
	return NULL;
}


static int _stp_shm_connect(const char *name)
{
	int rc = 0, fd = -1;
	struct stat st;
	void *base;

	// NB: since we're just connecting, we won't set _stp_shm_name,
	// so _stp_shm_destroy won't try to unlink it from this process.

	// Open the pre-existing shared memory
	fd = shm_open(name, O_RDWR, 0);
	if (fd < 0)
		rc = fd;

	// Find out the shared memory's size.
	// (This implies that the main process is done allocating.)
	if (rc == 0)
		rc = fstat(fd, &st);

	// Map it into this process.
	if (rc == 0) {
		base = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE,
			    MAP_SHARED, fd, 0);
		if (base == MAP_FAILED)
			rc = -1;
		else
			_stp_shm_base = base;
	}

	if (fd >= 0)
		close(fd);

	if (rc == 0)
		shm_dbug("connected pid %d to %s @ %p", getpid(), name, _stp_shm_base);
	return rc;
}


// Allocate space from shared memory
static void *_stp_shm_alloc(size_t size)
{
	void *alloc;

	// We're not initialized or already finalized.
	// Either way, we're not taking new requests.
	if (_stp_shm_fd < 0)
		return NULL;

	// Round up to 8-byte aligned sizes, just to be a little safer
	size = (size + 7) & ~7;
	if (size <= 0)
		return NULL; // either 0 requested or overflow

	// Check if more memory is needed.
	if (_stp_shm_size - _stp_shm_allocated < size) {
		void *new_base;

		// Round up to the nearest page size
		off_t new_size = _stp_shm_allocated + size;
		new_size += _stp_shm_page_size - 1;
		new_size /= _stp_shm_page_size;
		new_size *= _stp_shm_page_size;
		if (new_size < _stp_shm_allocated ||
		    new_size - _stp_shm_allocated < size)
			return NULL; // math overflow?

		// Try to resize the underlying file.
		if (ftruncate(_stp_shm_fd, new_size) < 0)
			return NULL;

		// Try to remap the address in memory.
		new_base = mremap(_stp_shm_base, _stp_shm_size,
				  new_size, MREMAP_MAYMOVE);
		if (new_base == MAP_FAILED)
			return NULL;

		// Update globals
		_stp_shm_size = new_size;
		_stp_shm_base = new_base;
	}

	// Finally return some memory.
	alloc = _stp_shm_base + _stp_shm_allocated;
	_stp_shm_allocated += size;
	return alloc;
}


// Allocate zeroed space from shared memory
static void *_stp_shm_zalloc(size_t size)
{
	void *ptr = _stp_shm_alloc(size);
	if (ptr)
		memset(ptr, 0, size);
	return ptr;
}


static void _stp_shm_free(void *ptr __attribute__((unused)))
{
	// NO-OP; we don't try to reclaim individual pieces.
}


// Signal that we're done allocating in shared memory.
// It won't be allowed to grow or move from here on out.
static void _stp_shm_finalize(void)
{
	if (_stp_shm_fd >= 0) {
		close(_stp_shm_fd);
		_stp_shm_fd = -1;
	}
	shm_dbug("mapped %" PRIi64 " bytes @ %p, used %" PRIi64, _stp_shm_size,
		 _stp_shm_base, _stp_shm_allocated);
}


// Tear down everything we created... *sniff*
// NB: Make sure not to reference any memory within after this!
// (Other processes may still have their own mmap reference though.)
// Don't destroy things in shm that may still be used by other processes!
static void _stp_shm_destroy(void)
{
	if (_stp_shm_base) {
		munmap(_stp_shm_base, _stp_shm_size);
		_stp_shm_base = NULL;
		_stp_shm_size = 0;
		_stp_shm_allocated = 0;
	}

	if (_stp_shm_fd >= 0) {
		close(_stp_shm_fd);
		_stp_shm_fd = -1;
	}

	if (_stp_shm_name[0]) {
		shm_unlink(_stp_shm_name);
		_stp_shm_name[0] = '\0';
	}
}


#endif /* _STAPDYN_SHM_H_ */