tools/diskomizer/shm_best_ops.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)shm_best_ops.c	1.16	09/05/26 SMI"

/*
 * shared memory operations.  They support the attaching and
 * detaching of shared memory, to reduce the overall address space
 * usage on a 32 bit system. All this extra work is a waste of
 * time on a 64 bit system at present.
 */
#include <stdlib.h>
#include <unistd.h>
#include <limits.h>
#include <stdio.h>
#include <errno.h>

#include <diskomizer/log.h>
#include "shm_ops.h"
#include "list.h"
#include <diskomizer/assert.h>

static struct shm_ops *all_ops[] = {&shm_bestshm_ops, &shm_mmap_ops, NULL};
static int hasfailed;
static struct best_shm *head;
struct best_shm {
	void *handle;
	void *addr;
	int ref;
	shm_flags flags;
	ulong_t len;
	struct shm_ops *ops;
	struct best_shm *allnext;
	struct best_shm *next;
	struct best_shm *prev;
};
struct list_head {
	struct best_shm *head;
	struct best_shm *tail;
};
static struct list_head free_list, active_list;

#define	PRINT_LIST(LIST_HEAD, NEXT) { \
	struct best_shm *x; \
	plog(LOG_DEBUG, "%s:%d %s\n", __FILE__, __LINE__, #LIST_HEAD); \
	for (x = LIST_HEAD; x != NULL; x = x->NEXT) { \
		plog(LOG_DEBUG, "List %s Handle %#lx, Addr %#lx, " \
			"ref %d type %s\n", #LIST_HEAD, \
			(ulong_t)x->handle, (ulong_t)x->addr, \
			x->ref, x->ops->name(x->handle)); \
		plog(LOG_DEBUG, "execute %d write %d allow_detach %d " \
			"always_detach %d\n", \
			x->flags.execute, x->flags.write, \
			x->flags.allow_detach, x->flags.always_detach); \
		plog(LOG_DEBUG, "x %#lx, next %#lx, prev %#lx, len %ld\n", \
			(ulong_t)x, (ulong_t)x->next, (ulong_t)x->prev, \
			x->len); \
	} \
}
static void *
my_alloc(size_t nelem, size_t elsize)
{
	void *res;
	long sbrkval;
	struct best_shm *q;

	res = calloc(nelem, elsize);
	if (res == NULL && (sbrkval = (long)sbrk(0))  != -1) {
		sbrkval += (nelem * elsize) + 8192;
		for (q = free_list.tail; q != NULL && res == NULL;
		    q = q->prev) {
			if (q->addr != NULL && q->ref == 0)
				if ((ulong_t)q->addr <= sbrkval) {
				if (q->ops->detach(q->handle) !=
				    SHM_DETACH_ERR) {
					q->addr = NULL;
					res = calloc(nelem, elsize);
				}
			}
		}
	}
	for (q = free_list.tail; q != NULL && res == NULL; q = q->prev) {
		if (q->addr != NULL && q->ref == 0) {
			if (q->ops->detach(q->handle) != SHM_DETACH_ERR) {
				q->addr = NULL;
				res = calloc(nelem, elsize);
			}
		}
	}
	return (res);
}

void
try_init(struct best_shm *x, long a, long b, shm_flags flags)
{
	struct best_shm *q;
	int i;

	for (i = flags.allow_detach ? 0 : 1; all_ops[i] != NULL; i++) {
		x->ops = all_ops[i];
		flags.always_detach = 1;
		if ((x->handle = x->ops->init(a, b, flags)) != NULL) {
			x->addr = x->ops->attach(x->handle);
			for (q = free_list.tail; x->addr == NULL && q != NULL;
			    q = q->prev) {
				assert(q->ref == 0);
				if (q->addr != NULL && q->flags.allow_detach &&
				    q->ops->detach(q->handle) !=
				    SHM_DETACH_ERR) {
					q->addr = NULL;
					x->addr = x->ops->attach(x->handle);
				}
			}
			if (x->addr != NULL) {
				break;
			} else {
				x->ops->destroy(x->handle);
			}
		}
	}
}
void *
best_init(long a, long b, shm_flags flags)
{
	struct best_shm *x;
	struct best_shm *q;

	x = my_alloc(1, sizeof (struct best_shm));
	if (x == NULL)
		return (NULL);
	x->flags = flags;

	try_init(x, a, b, flags);
	for (q = free_list.tail; x->handle == NULL && q != NULL; q = q->prev) {
		if (q->addr != NULL && q->flags.allow_detach) {
			assert(q->ref == 0);
			if (q->ops->detach(q->handle) != SHM_DETACH_ERR) {
				q->addr = NULL;
				try_init(x, a, b, flags);
			}
		}
	}
	if (x->handle == NULL) {
		free(x);
		return (NULL);
	} else {
		x->allnext = head;
		head = x;
	}
	x->len = a * b;
	x->ref = 0;
	LIST_ADD(&free_list, x);
	return (x);
}
static ulong_t
best_max_size(void)
{
	ulong_t size = 0;
	int i;

	for (i = 0; all_ops[i] != NULL; i++) {
		ulong_t tmp = all_ops[i]->max_size();
		if (tmp > size)
			size = tmp;
	}
	return (size);
}

/*
 * The shared memeory is not attached so attach it. If it can't be attached
 * try detaching other segments until it can be attached or all have been
 * detached.
 */
static void *
best_do_attach(struct best_shm *x)
{
	struct best_shm *q;

	x->addr = x->ops->attach(x->handle);
	for (q = free_list.tail; x->addr == NULL && q != NULL; q = q->prev) {
		shm_det_status status;

		hasfailed = 1;
		if (q->ref != 0) {
			PRINT_LIST(head, allnext);

			PRINT_LIST(free_list.head, next);
			PRINT_LIST(active_list.head, next);
			exit(1);
		}
		if ((errno != EMFILE || q->ops == x->ops)) {
			if (q->addr != NULL && q->flags.allow_detach &&
			    (status = q->ops->detach(q->handle)) !=
			    SHM_DETACH_ERR) {
				q->addr = NULL;
				if (status == SHM_DETACH_DONE) {
					x->addr = x->ops->attach(x->handle);
				}
			}
		}
	}
	for (q = free_list.tail; x->addr == NULL && q != NULL; q = q->prev) {
		if (q->addr != NULL && q->flags.allow_detach &&
		    q->ops->detach(q->handle) == SHM_DETACH_DONE) {
			q->addr = NULL;
			x->addr = x->ops->attach(x->handle);
		}
	}
	if (x->addr != NULL) {
		if (x->ref == 0) {
			LIST_REMOVE(&free_list, x);
			LIST_ADD(&active_list, x);
		}
		x->ref++;
	} else {
		pperror("Can't attach %s", x->ops->name(x));
		PRINT_LIST(head, allnext);
		PRINT_LIST(free_list.head, next);
	}
	return (x->addr);

}

static void *
best_attach(void * arg)
{
	struct best_shm *x = (struct best_shm *)arg;
	if (x->addr == NULL) {
		return (best_do_attach(x));
	} else {
		if (x->ref == 0) {
			LIST_REMOVE(&free_list, x);
			LIST_ADD(&active_list, x);
		}
		x->ref++;
		return (x->addr);
	}
}

static shm_det_status
best_move_to_free(struct best_shm *x)
{
	shm_det_status status;

	LIST_REMOVE(&active_list, x);
	LIST_ADD(&free_list, x);
	if (x->flags.always_detach) {
		if ((status = x->ops->detach(x->handle)) != SHM_DETACH_ERR) {
			x->addr = NULL;
			return (status);
		} else {
			return (SHM_DETACH_ERR);
		}
	}
	return (SHM_DETACH_OK);
}
shm_det_status
best_detach(void *arg)
{
	struct best_shm *x = (struct best_shm *)arg;

	if (--(x->ref) == 0) {
		return (best_move_to_free(x));
	}
	return (SHM_DETACH_OK);
}

void
best_destroy(void *arg)
{
	struct best_shm *x = (struct best_shm *)arg;
	x->ops->destroy(x->handle);
	free(x);
}
static char name[] = "best";
const char *
best_name(void *arg)
{
	struct best_shm *x = (struct best_shm *)arg;
	if (x != NULL)
		return (x->ops->name(x->handle));
	return (&name[0]);
}
const char *
best_longname(void *arg)
{
	struct best_shm *x = (struct best_shm *)arg;
	if (x != NULL)
		return (x->ops->longname(x->handle));
	return (&name[0]);
}
static int
best_is_short_of_mem(void)
{
	return (hasfailed);
}
static void
best_complete(void *handle)
{
	int i;
	for (i = 0; all_ops[i] != NULL; i++) {
		all_ops[i]->complete(handle);
	}
}
static void
best_fini(void)
{
	int i;
	for (i = 0; all_ops[i] != NULL; i++) {
		all_ops[i]->fini();
	}
}

struct shm_ops shm_best_ops = {
	best_name,
	best_longname,
	best_init,
	best_attach,
	best_detach,
	best_destroy,
	best_max_size,
	best_is_short_of_mem,
	best_complete,
	best_fini
};