tools/diskomizer/shm_mmap_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_mmap_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, unless someone has decreased
 * some of the limits.
 *
 * Still to do:
 *	The fd should not be held in the mmap_shm structure, but
 *	in a seperate structure with a reference count.  When
 *	the reference count drops to 0 the fd can be closed.
 *
 *	Currently it is possible, to leak file descriptors, but
 *	this will only happen during error paths, most if not all
 *	of which are fatal so it won't impact the program.
 */
#ifndef _LARGEFILE64_SOURCE
#define	_LARGEFILE64_SOURCE
#endif
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <errno.h>
#include <string.h>
#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include "shm_ops.h"
#include <diskomizer/log.h>
#include <diskomizer/stack_trace.h>
#include "signal_catch.h"
#include "args.h"
#include "list.h"
#include "utils.h"

struct list_head {
	struct mmap_shm *head;
	struct mmap_shm *tail;
};
struct mmap_shm {
	struct mmap_shm *next;
	struct mmap_shm *prev;
	shm_flags flags;
	int fd;
	off_t off;
	int ref;
	int users;
	void *addr;
	ulong_t len;
};
struct frag {
	struct mmap_shm *base;
	off_t off;
};
struct free_frags {
	struct free_frags *next;
	struct free_frags *prev;
	struct frag *frag;
	ulong_t len;
};

static struct free_frags free_frag;
static struct list_head free_list, attach_list;
static int hasfailed;
static struct fd {
	int fd;
	off_t trunc;
	off_t off;
} fd = {
	-1,
	0,
	0
};
static void *
my_alloc(size_t nelem, size_t elsize)
{
	void *res;
	long sbrkval;
	struct mmap_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 &&
			    (ulong_t)q->addr <= sbrkval) {
				if (munmap(q->addr, q->len) == -1) {
					pperror("%d, munmap(%lx, %lx)",
					    __LINE__, (ulong_t)q->addr, q->len);
				} else {
					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 (munmap(q->addr, q->len) == -1) {
				pperror("%d, munmap(%lx, %lx)", __LINE__,
				    (ulong_t)q->addr, q->len);
			} else {
				res = calloc(nelem, elsize);
				if (res == NULL)
					q->addr = NULL;
				else
					q->addr = NULL;
			}
		}
	}
	return (res);
}

static int
create_temp(void)
{
	char xtempfile[] = "mmap_memory_file_XXXXXX";
	char *tempfile, *tmp;
	int fd;

	tempfile = my_alloc(1, strlen(xtempfile) +
	    strlen(opts.mmap_file_directory) + 2);
	if (tempfile == NULL) {
		return (-1);
	}
	(void) sprintf(tempfile, "%s/%s", opts.mmap_file_directory,
	    xtempfile);

	tmp = mktemp(tempfile);
	if ((fd = get_high_fd(open(tmp, O_RDWR|O_CREAT|O_EXCL,
	    S_IRUSR|S_IWUSR|S_ISVTX))) == -1) {
		int saveerrno = errno;
		free(tempfile);
		errno = saveerrno;
	} else {
		(void) unlink(tmp);
		free(tempfile);
	}
	return (fd);
}
void *
mmap_init(long a, long b, shm_flags flags)
{
	struct mmap_shm *x;
	struct mmap_shm *q;
	int prot = PROT_READ | PROT_WRITE |
	    (flags.execute == 1 ? PROT_EXEC : 0);
	int use_dev_zero = !(flags.allow_detach ||
	    opts.expert_always_mmap_from_file);

	if ((x = (struct mmap_shm *)my_alloc(1, sizeof (struct mmap_shm))) ==
	    NULL) {
		return (NULL);
	}

	assert(a);
	assert(b);
	x->len = a * b;
	assert(x->len != 0);
	x->flags = flags;
	x->flags.write = 1;

	if (!use_dev_zero) {
		int pagesz = sysconf(_SC_PAGESIZE);
		do {
			if (fd.fd == -1) {
				if ((x->fd = create_temp()) == -1) {
					int saveerrno = errno;
					free(x);
					errno = saveerrno;
					return (NULL);
				}
				fd.fd = x->fd;
				fd.trunc =  fd.off = 0;
			} else {
				x->fd = fd.fd;
			}
			if (fd.off + x->len > fd.trunc) {
				off_t old_trunc = fd.trunc;
				while (fd.off + x->len > fd.trunc)
					fd.trunc += 100 * 1024 * pagesz;
				if (ftruncate(x->fd, fd.trunc) == -1) {
					int e;
					fd.trunc = old_trunc + x->len +
					    (pagesz - (x->len % pagesz));
					/*
					 * Try to just get what is needed now.
					 * It may be enough!
					 */
					if (ftruncate(x->fd, fd.trunc) != -1) {
						break;
					}
					e = errno;
					/*
					 * Shrink the file back to match
					 * what is actually being used.
					 */
					(void) ftruncate(x->fd, fd.off);
					errno = e;

					if (errno != EFBIG && errno != EINVAL) {
						fd.trunc = old_trunc;
						pperror("ftruncate(%d, %llX)",
						    x->fd, (long long)fd.trunc);
						return (NULL);
					}
					fd.fd = -1;
				}
			}
		} while (fd.fd == -1);
		x->off = fd.off;
		fd.off = fd.off + x->len + (pagesz - (x->len % pagesz));
	} else {
		if ((x->fd = open("/dev/zero", O_RDWR, 0600)) == -1) {
			int saveerrno = errno;
			free(x);
			errno = saveerrno;
			return (NULL);
		}
		x->off = 0;
	}

	if (opts.fast_start && flags.allow_detach) {
		x->addr = NULL;
		x->ref = 0;
		LIST_ADD(&free_list, x);
		return (x);
	}
	x->addr = mmap(0, x->len, prot, MAP_SHARED, x->fd, x->off);
	x->ref = 0;

	for (q = free_list.tail; q != NULL && x->addr == MAP_FAILED;
	    q = q->prev) {
		hasfailed = 1;
		if (x->len != q->len)
			continue;
		if (q->addr != NULL && q->ref == 0) {
			if (munmap(q->addr, q->len) == -1) {
				pperror("munmap(%lx, %lx)",
				    (ulong_t)q->addr, q->len);
			} else {
				q->addr = NULL;
			}
			x->addr = mmap(0, x->len, prot,
			    MAP_SHARED, x->fd, x->off);
		}
	}
	for (q = free_list.tail; q != NULL && x->addr == MAP_FAILED;
	    q = q->prev) {
		if (q->addr != NULL && q->ref == 0) {
			if (munmap(q->addr, q->len) == -1) {
				pperror("munmap(%lx, %lx)",
				    (ulong_t)q->addr, q->len);
			} else {
				q->addr = NULL;
			}
			x->addr = mmap(0, x->len, prot,
			    MAP_SHARED, x->fd, x->off);
		}
	}

	if (x->addr == MAP_FAILED) {
		(void) close(x->fd);
		free(x);
		return (NULL);
	}
	if (!use_dev_zero) {
		/*
		 * Be ready to take SIGBUS if there is no enough free
		 * memory to allocate this page and then be able to
		 * report a sensible failure message.
		 */
		void *sig = expect_signal(SIGBUS, "memset", x->addr, a *b);
		(void) memset(x->addr, NULL, a * b);
		cancel_expected_signal(SIGBUS, sig);
		if (x->flags.always_detach || !flags.leave_attached) {
			if (munmap(x->addr, x->len) == -1)
				pperror("munmap(%lx, %lx)",
				    (ulong_t)x->addr, x->len);
			else
				x->addr = NULL;
		}
	} else {
		if (close(x->fd) != -1)
			x->fd = -1;
	}
	LIST_ADD(&free_list, x);
	assert(x->addr != MAP_FAILED);
	return (x);
}
void *
mmap_attach(void * arg)
{
	struct mmap_shm *x = (struct mmap_shm *)arg;

	if (x->addr == NULL) {
		struct mmap_shm *q;
		void *hint = NULL; /* may get passed in as an arg in future */
		int prot =  PROT_READ |
		    (x->flags.write ? PROT_WRITE : 0) |
		    (x->flags.execute ? PROT_EXEC : 0);
		x->addr = mmap(hint, x->len, prot, MAP_SHARED,
		    x->fd, x->off);
		for (q = free_list.tail; q != NULL && x->addr == MAP_FAILED;
		    q = q->prev) {
			hasfailed = 1;
			if (x->len != q->len)
				continue;
			if (q != x && q->addr != NULL) {
				if (munmap(q->addr, q->len) == -1) {
					pperror("munmap(%lx, %lx)",
					    (ulong_t)q->addr, q->len);
				} else {
					hint = q->addr;
					q->addr = NULL;
				}
				x->addr = mmap(hint, x->len, prot,
				    MAP_SHARED, x->fd, x->off);
			}
		}
		for (q = free_list.tail; q != NULL && x->addr == MAP_FAILED;
		    q = q->prev) {
			if (q != x && q->addr != NULL) {
				if (munmap(q->addr, q->len) == -1) {
					pperror("munmap(%lx, %lx)",
					    (ulong_t)q->addr, q->len);
				} else {
					hint = q->addr;
					q->addr = NULL;
				}
				x->addr = mmap(hint, x->len, prot,
				    MAP_SHARED, x->fd, x->off);
			}
		}
		if (x->addr == MAP_FAILED) {
			x->addr = NULL;
		}
	}
	if (x->addr != NULL) {
		if (x->ref++ == 0) {
			LIST_REMOVE(&free_list, x);
			LIST_ADD(&attach_list, x);
		}
	}
	assert(x->addr != MAP_FAILED);
	return (x->addr);
}
shm_det_status
mmap_detach(void *arg)
{
	struct mmap_shm *x = (struct mmap_shm *)arg;

	if (x->flags.allow_detach) {
		if (--(x->ref) == 0) {
			LIST_REMOVE(&attach_list, x);
			LIST_ADD(&free_list, x);
			if (x->flags.always_detach) {
				if (munmap(x->addr, x->len) != -1) {
					x->addr = NULL;
					return (SHM_DETACH_DONE);
				} else {
					return (SHM_DETACH_ERR);
				}
			}
		}
	}
	return (SHM_DETACH_OK);
}
void
mmap_destroy(void *arg)
{
	struct mmap_shm *x = (struct mmap_shm *)arg;

	if (--(x->users) != 0)
		return;
	if (x->addr) {
		if (munmap(x->addr, x->len) == -1)
			x->addr = NULL;
	}
/*
 *
 *	if (x->fd) {
 *		(void) close(x->fd);
 *	}
 */
	free(x);
}
ulong_t
mmap_max_size()
{
	return (opts.expert_mmap_max_size);
}
/*ARGSUSED*/
const char *
mmap_name(void *x)
{
	static char name[] = "mmap_no_frag";
	return (&name[0]);
}
static int
mmap_is_short_of_mem(void)
{
	return (hasfailed);
}
/*ARGSUSED*/
static void
mmap_complete(void * handle)
{
	if (fd.off != fd.trunc && fd.fd != -1) {
		if (ftruncate(fd.fd, fd.off) == -1) {
			pperror("ftruncate(%d, %llX)", fd.fd,
			    (long long)fd.trunc);
		} else {
			plog(LOG_DEBUG, "ftruncate(%d, %llX)\n",
			    fd.fd, (long long) fd.trunc);
		}
	}
}

void *
frag_init(long a, long b, shm_flags flags)
{
	struct frag *f;
	struct free_frags *ff;
	long len = a * b;
	int pagesz = sysconf(_SC_PAGESIZE);

	len = ROUND_UP(len, sizeof (long long));

	if (pagesz > len) {
		for (ff = &free_frag; ff != NULL && ff->frag != NULL;
		    ff = ff->next) {
			if (len <= ff->len && memcmp(&flags,
			    &ff->frag->base->flags, sizeof (flags))) {
				/* Bingo */
				if (ff->len - len < sizeof (off64_t)) {
					if (ff->prev != NULL) {
						ff->prev->next = ff->next;
					}
					if (ff->next != NULL) {
						ff->next->prev = ff->prev;
					}
					f = ff->frag;
					if (ff == &free_frag) {
						ff->frag = NULL;
						ff->prev = NULL;
						ff->next = NULL;
					} else {
						free(ff);
					}
				} else {
					if ((f = my_alloc(1,
					    sizeof (struct frag))) == NULL) {
						return (NULL);
					}
					*f = *ff->frag;
					ff->len -= len;
					ff->frag->off += len;
				}
				f->base->users++;
				return (f);
			}
		}
		/* nothing suitable */
		if ((f = my_alloc(1, sizeof (struct frag))) == NULL) {
			return (NULL);
		}
		if ((f->base = mmap_init(1, pagesz, flags)) == NULL) {
			free(f);
			return (NULL);
		}
		f->off = 0;
		if ((pagesz - len) >= sizeof (long long)) {
			if (free_frag.frag == NULL) {
				ff = &free_frag;
				if ((ff->frag = my_alloc(1,
					sizeof (struct frag))) == NULL) {
					return (NULL);
				}
			} else if ((ff = my_alloc(1,
					sizeof (struct free_frags))) == NULL) {
				return (NULL);
			} else {
				if ((ff->frag = my_alloc(1,
					sizeof (struct frag))) == NULL) {
					free(ff);
					return (NULL);
				}
				ff->next = free_frag.next;
				if (free_frag.next != NULL) {
					free_frag.next->prev = ff;
				}
				ff->prev = &free_frag;
				free_frag.next = ff;
			}
			ff->frag->base = f->base;
			ff->frag->off = len;
			ff->len = pagesz - len;
		}
	} else {
		if ((f = my_alloc(1, sizeof (struct frag))) == NULL) {
			return (NULL);
		}
		if ((f->base = mmap_init(1, len, flags)) == NULL) {
			free(f);
			return (NULL);
		}
		f->off = 0;
	}
	f->base->users++;
	return (f);
}

static void *
frag_attach(void *arg)
{
	struct frag *f = (struct frag *)arg;
	char *addr;

	if ((addr = mmap_attach(f->base)) == NULL) {
		return (NULL);
	} else {
		return ((void *)(addr + f->off));
	}
}

static shm_det_status
frag_detach(void *arg)
{
	struct frag *f = (struct frag *)arg;
	return (mmap_detach(f->base));
}

/*ARGSUSED*/
static const char *
frag_name(void *arg)
{
	static char name[] = "mmap";
	return (&name[0]);
}

static void
frag_destroy(void *arg)
{
	struct frag *f = (struct frag *)arg;
	mmap_destroy(f->base);
}

static void
mmap_fini(void)
{
}


struct shm_ops shm_mmap_no_frag_ops = {
	mmap_name,
	mmap_name,
	mmap_init,
	mmap_attach,
	mmap_detach,
	mmap_destroy,
	mmap_max_size,
	mmap_is_short_of_mem,
	mmap_complete,
	mmap_fini
	/* mmap_garbage_collect */
};
struct shm_ops shm_mmap_ops = {
	frag_name,
	frag_name,
	frag_init,
	frag_attach,
	frag_detach,
	frag_destroy,
	mmap_max_size,
	mmap_is_short_of_mem,
	mmap_complete,
	mmap_fini
	/* mmap_garbage_collect */
};