tools/diskomizer/shm_shm_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_shm_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.
 *
 * It also allows diskomizer to better cope with the default values
 * of the shmsys settings in /etc/system.
 */
/*
 * To use shared memory you have to tweak the following in /etc/system
 *
 * set shmsys:shminfo_shmmax=0x100000000
 * set shmsys:shminfo_shmmin=0x10
 * set shmsys:shminfo_shmseg=20000
 * set shmsys:shminfo_shmmni=20000
 */
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include "args.h"
#include <diskomizer/log.h>
#include "list.h"

#define	MAX(A, B) ((A) > (B) ? (A) : (B))
#define	MIN(A, B) ((A) < (B) ? (A) : (B))

#include "shm_ops.h"
#define	USE_ISM 0x1
#define	SHM_BEST 0x2
#define	USE_SHM_PAGEABLE 0x4

/*
 * Stolen from the SunOS 5.8 header file so that this will build on 5.6 and 5.7
 */
#ifndef SHM_PAGEABLE
#define	SHM_PAGEABLE 0100000
#endif

struct list_head {
	struct shm_seg *head;
	struct shm_seg *tail;
};
struct shm_seg {
	struct shm_seg *next;
	struct shm_seg *prev;
	struct shm_seg *full_list;
	shm_flags flags;
	long len;
	long used; /* len - used == free */
	int number_of_users;
	int ref;
	int shmid;
	pid_t pid;
	void *addr;
	void *oldaddr;
};

struct shm_shm {
	struct shm_seg *seg;
	/* shm_flags flags; */
	long len;
	void *addr;
	ulong_t offset;
};

static struct list_head free_list, attach_list;
static struct shm_seg *full_list;
static int hasfailed;

static struct shm_seg *
seg_init(long wanted, shm_flags flags)
{
	struct shm_seg *this;
	struct shm_seg *found = NULL;
	int shmflg = 0700 |
	    ((flags.private & (USE_ISM|SHM_BEST)) ?  SHM_SHARE_MMU : 0) |
	    ((flags.private & USE_SHM_PAGEABLE) ? SHM_PAGEABLE : 0);

	if (wanted > opts.shminfo_shmmax) {
		errno = ENOMEM;
		return (NULL);
	}

	for (this = full_list; this != NULL; this = this->full_list) {
		if (flags.allow_detach == this->flags.allow_detach &&
		    wanted < (this->len - this->used)) {
			/*
			 * bingo now onlu use it if it is the smallest one
			 * that will do.
			 */
			if (found == NULL || (found->len - found->used) >
			    (this->len - this->used)) {
				found = this;
			}
		}
	}
	if (found != NULL) {
		found->number_of_users++;
		found->used += wanted;
		/* Fix the alignment for the largest type */
		found->used += (found->used % sizeof (long long));
		return (found);
	}
	if ((this = calloc(1, sizeof (struct shm_seg))) == NULL) {
		free(this);
		return (NULL);
	}
	this->shmid = -1;
	this->next = this->prev = NULL;
	this->flags = flags;
	this->pid = getpid();
	this->addr = NULL;
	this->len = opts.shminfo_shmmax;
	this->number_of_users = 1;
	this->used = wanted;
	/* Fix the alignment for the largest type */
	this->used += (this->used % sizeof (long long));
	this->full_list = full_list;
	full_list = this;
	this->ref = 0;

	this->shmid = shmget(IPC_PRIVATE, opts.shminfo_shmmax, shmflg);
	if (this->shmid == -1) {
		this->shmid = shmget(IPC_PRIVATE, wanted, shmflg);
		if (this->shmid != -1) {
			this->len = wanted;
			this->used = wanted;
		} else if (flags.private & SHM_BEST) {
			this->shmid = shmget(IPC_PRIVATE, opts.shminfo_shmmax,
			    0700);
			if (this->shmid == -1) {
				full_list = this->full_list;
				free(this);
				return (NULL);
			}
		}
	}
	LIST_ADD(&free_list, this);
	assert(this->addr != (void*)-1);
	return (this);
}

static void *
seg_attach(struct shm_seg *seg)
{
	struct shm_seg *x;
	if (seg->addr == NULL) {
		int shmflg;

		shmflg = ((seg->flags.private & (USE_ISM|SHM_BEST)) ?
		    SHM_SHARE_MMU : 0) |
		    ((seg->flags.private & USE_SHM_PAGEABLE) ?
		    SHM_PAGEABLE : 0);

		seg->addr = shmat(seg->shmid, NULL, shmflg);
		if (errno != EMFILE && seg->addr == (void *)-1L &&
		    seg->flags.private & SHM_BEST) {
			seg->addr = shmat(seg->shmid, NULL, 0);
		}

		for (x = free_list.tail; x != NULL && seg->addr == (void *)-1L;
		    x = x->prev) {
			if (x != seg && x->flags.allow_detach &&
			    x->ref == 0 && x->addr != NULL) {
				assert(x->addr != (void *)-1L);
				if (shmdt(x->addr) == 0) {
					x->oldaddr = x->addr;
					x->addr = NULL;
					seg->addr =
					    shmat(seg->shmid, NULL, shmflg);
					if (errno != EMFILE &&
					    seg->addr == (void *)-1L &&
					    seg->flags.private & SHM_BEST) {
						seg->addr = shmat(seg->shmid,
						    NULL, 0);
					}
				}
			}
		}
		if (seg->addr == (void *)-1L) {
			seg->addr = NULL;
			return (NULL);
		}
	}

	if ((seg->ref)++ == 0) {
		LIST_REMOVE(&free_list, seg);
		LIST_ADD(&attach_list, seg);
	}
	return (seg->addr);
}
static shm_det_status
seg_detach(struct shm_seg *seg)
{
	if (seg->flags.allow_detach) {
		if (--(seg->ref) == 0) {
			LIST_REMOVE(&attach_list, seg);
			LIST_ADD(&free_list, seg);
			if (seg->flags.always_detach) {
				if (shmdt(seg->addr) == 0) {
					seg->oldaddr = seg->addr;
					seg->addr = NULL;
					return (SHM_DETACH_DONE);
				} else {
					return (SHM_DETACH_ERR);
				}
			}
		}
	}
	assert(seg->addr != (void *)-1L);
	return (SHM_DETACH_OK);
}
static void
seg_destroy(struct shm_seg *seg)
{
	if (--(seg->number_of_users) == 0) {
		struct shm_seg *tmp;
		assert(seg->ref == 0);
		LIST_REMOVE(&free_list, seg);

		if (seg == full_list) {
			full_list = full_list->full_list;
		} else {
			for (tmp = full_list; tmp->full_list != seg;
			    tmp = tmp->full_list)
				/* empty */;
			tmp->full_list = tmp->full_list->full_list;
		}
		if (seg->addr != NULL)
			if (shmdt(seg->addr) != NULL)
				pperror("shmdt(%#lx)", (ulong_t)seg->addr);
		if (shmctl(seg->shmid, IPC_RMID, NULL) == -1)
			pperror("shmctl(%d, IPC_RMID, NULL)", seg->shmid);
		free(seg);
	}
}

int
onlist(struct list_head *list_head,  struct shm_seg *entry)
{
	struct shm_seg *x;

	for (x = list_head->head; x != NULL; x = x->next)
		if (x == entry)
			return (1);
	return (0);
}

static void
shm_fini(void)
{
	pid_t pid = getpid();
	struct shm_seg *q;
	for (q = full_list; q != NULL; q = q->full_list) {
		if (q->pid == pid && q->shmid != -1) {
			if (shmctl(q->shmid, IPC_RMID, NULL) == -1)
				pperror("shmctl(%d, IPC_RMID, NULL)",
				    q->shmid);
			else
				q->shmid = -1;
		}
	}
}

#ifdef SEGV_TEST
void
segv(void)
{
	int *x;
	x = segv;
	*x = 0;
}
#endif

void *
shm_init(long a, long b, shm_flags flags)
{
	struct shm_shm *x;

#ifdef SEGV_TEST
	segv(); /* Debugging */
#endif

	x = calloc(1, sizeof (struct shm_shm));
	if (x == NULL)
		return (NULL);
	x->len = a * b;
	if ((x->seg = seg_init(x->len, flags)) == NULL) {
		free(x);
		return (NULL);
	}
	x->offset = x->seg->used - (x->len);


	if (!flags.allow_detach) {
		if (seg_attach(x->seg) == NULL) {
			free(x);
			return (NULL);
		}
		x->addr = (void *)((ulong_t)x->seg->addr + x->offset);
	} else  {
		x->addr = NULL;
	}
	return (x);
}
void *
shm_attach(void * arg)
{
	struct shm_shm *x = (struct shm_shm *)arg;
	void *addr; /* the base address of this segment */

	addr = seg_attach(x->seg);

	if (addr == NULL)
		return (NULL);

	if (x->addr == NULL) {
		x->addr = (void *)((ulong_t)x->seg->addr + x->offset);
	}
	assert(x->addr == (void *)((ulong_t)x->seg->addr + x->offset));
	assert(((ulong_t)x->addr - (ulong_t)addr) + x->len <= x->seg->len);
	assert(x->addr != (void *)-1L);
	return (x->addr);
}
shm_det_status
shm_detach(void *arg)
{
	struct shm_shm *x = (struct shm_shm *)arg;
	x->addr = NULL;
	return (seg_detach(x->seg));
}
void
shm_destroy(void *arg)
{
	struct shm_shm *x = (struct shm_shm *)arg;
	seg_destroy(x->seg);
	free(arg);
}

void *
shm_best_init(long a, long b, shm_flags flags)
{
	flags.private = USE_ISM | SHM_BEST |
	    (opts.shm_pageable ? USE_SHM_PAGEABLE : 0);

	return (shm_init(a, b, flags));
}

void *
ism_init(long a, long b, shm_flags flags)
{
	flags.private = USE_ISM |
	    (opts.shm_pageable ? USE_SHM_PAGEABLE : 0);

	return (shm_init(a, b, flags));
}

/*ARGSUSED*/
const char *
ism_name(void *x)
{
	static char ismname[] = "ism";
	return (&ismname[0]);
}
/*ARGSUSED*/
const char *
ism_longname(void *x)
{
	static char ismname[] = "intimate shared memory";
	return (&ismname[0]);
}
/*ARGSUSED*/
const char *
shm_best_name(void * arg)
{
	static char name[] = "best_shm";
	return (&name[0]);
}
/*ARGSUSED*/
const char *
shm_best_longname(void * arg)
{
	static char name[] = "best shared memory";
	return (&name[0]);
}
/*ARGSUSED*/
const char *
shm_name(void * arg)
{
	static char name[] = "shm";
	return (&name[0]);
}
/*ARGSUSED*/
const char *
shm_longname(void * arg)
{
	static char name[] = "shared memory";
	return (&name[0]);
}
ulong_t
shm_max_size(void)
{
	return (opts.shm_max_size);
}
static int
shm_is_short_of_mem(void)
{
	return (hasfailed);
}
/*ARGSUSED*/
static void
shm_complete(void *handle)
{
	static char max_wasted_str[] = "shm_complete max_bytes wasted";
	static char wasted_str[] = "shm_complete bytes wasted";
	static char allocated_str[] = "shm_complete bytes allocated";
	struct shm_seg *this;
	long long wasted = 0;
	long long max_wasted = 0;
	long long min_wasted = LONGLONG_MAX;
	long long allocated = 0;

	for (this = full_list; this != NULL; this = this->full_list) {
		wasted += (this->len - this->used);
		max_wasted = MAX(max_wasted, (this->len - this->used));
		min_wasted = MIN(min_wasted, (this->len - this->used));
		allocated += this->len;
	}
	plog_number_of_bytes(LOG_NOTICE, allocated, allocated_str,
	    allocated_str);
	plog_number_of_bytes(LOG_NOTICE, wasted, wasted_str, wasted_str);
	plog_number_of_bytes(LOG_NOTICE, max_wasted,
	    max_wasted_str, max_wasted_str);
}

struct shm_ops shm_bestshm_ops = {
	shm_best_name,
	shm_best_longname,
	shm_best_init,
	shm_attach,
	shm_detach,
	shm_destroy,
	shm_max_size,
	shm_is_short_of_mem,
	shm_complete,
	shm_fini
};
struct shm_ops shm_ism_ops = {
	ism_name,
	ism_longname,
	ism_init,
	shm_attach,
	shm_detach,
	shm_destroy,
	shm_max_size,
	shm_is_short_of_mem,
	shm_complete,
	shm_fini
};
struct shm_ops shm_shm_ops = {
	shm_name,
	shm_longname,
	shm_init,
	shm_attach,
	shm_detach,
	shm_destroy,
	shm_max_size,
	shm_is_short_of_mem,
	shm_complete,
	shm_fini
};