xref: /dflybsd-src/usr.sbin/sysvipcd/shmd.c (revision 1b11ea06a427d663e12e6a7a5083df6209e4cda2)

/*
 * Copyright (c) 1994 Adam Glass and Charles Hannum.  All rights reserved.
 * Copyright (c) 2013 Larisa Grigore <larisagrigore@gmail.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by Adam Glass and Charles
 *	Hannum.
 * 4. The names of the authors may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/vmmeter.h>
#include <sys/wait.h>
#include <sys/queue.h>
#include <sys/mman.h>

#include <err.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>

#include "limits.h"
#include "perm.h"
#include "utilsd.h"

#include "shmd.h"
#include "sysvipc_hash.h"
#include "sysvipc_sockets.h"

static struct	shminfo shminfo = {
//	0,
	SHMMIN,
	SHMMNI,
	SHMSEG
//	0
};

/* Shared memory.*/
static int shm_last_free, shm_committed, shmalloced;
int shm_nused;
static struct shmid_ds	*shmsegs;

/* Message queues.*/
extern struct msginfo msginfo;

extern struct hashtable *clientshash;

static int
create_sysv_file(struct shmget_msg *msg, size_t size,
		struct shmid_ds *shmseg) {
	char filename[FILENAME_MAX];
	int fd;
	void *addr;
	int nsems;
	struct semid_pool *sems;
	struct msqid_pool *msgq;
	key_t key = msg->key;
	int i;

	errno = 0;

	switch(msg->type) {
		case SHMGET:
			sprintf(filename, "%s/%s_%ld", DIRPATH, SHM_NAME, key);
			break;
		case SEMGET:
			sprintf(filename, "%s/%s_%ld", DIRPATH, SEM_NAME, key);
			break;
		case MSGGET:
			sprintf(filename, "%s/%s_%ld", DIRPATH, MSG_NAME, key);
			break;
		case UNDOGET:
			sprintf(filename, "%s/%s_%ld", DIRPATH, UNDO_NAME, key);
			break;
		default:
			return (-EINVAL);
	}

	fd = open(filename, O_RDWR | O_CREAT, 0666);
	if (fd < 0) {
		sysvd_print_err("create sysv file: open\n");
		goto out;
	}

	ftruncate(fd, size);

	switch(msg->type) {
		case SEMGET:
			/* Map the semaphore to initialize it. */
			addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
			//TODO modify 0 for more sems on a page
			if (!addr) {
				sysvd_print_err("create sysv file: mmap");
				goto error;
			}

			/* There is no need for any lock because all clients
			 * that try to access this segment are blocked until
			 * it becames ~SHMSEG_REMOVED. */
			sems = (struct semid_pool*)addr;
			nsems = (msg->size - sizeof(struct semid_pool)) /
				sizeof(struct sem);
			sysvd_print("allocate %d sems\n", nsems);

			/* Init lock. */
#ifdef SYSV_RWLOCK
			sysv_rwlock_init(&sems->rwlock);
#else
			sysv_mutex_init(&sems->mutex);
#endif
			/* Credentials are kept in shmid_ds structure. */
			sems->ds.sem_perm.seq = shmseg->shm_perm.seq;
			sems->ds.sem_nsems = nsems;
			sems->ds.sem_otime = 0;
			//sems->ds.sem_ctime = time(NULL);
			//semtot += nsems;
			sems->gen = 0;

			/* Initialize each sem. */
			memset(sems->ds.sem_base, 0, nsems + sizeof(struct sem));

#ifdef SYSV_SEMS
			int l;
			for (l=0; l < nsems; l++)
				sysv_mutex_init(&sems->ds.sem_base[l].sem_mutex);
#endif

			munmap(addr, size);

			break;
		case MSGGET:
			/* Map the message queue to initialize it. */
			addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
			if (!addr) {
				sysvd_print_err("create sysv file: mmap");
				goto error;
			}

			/* There is no need for any lock because all clients
			 * that try to access this segment are blocked until
			 * it becames ~SHMSEG_REMOVED. */
			msgq = (struct msqid_pool*)addr; //TODO
			/*sysvd_print("Attention!!! : %ld %ld %ld %ld\n",
					sizeof(struct msqid_pool),
					sizeof(msgq->msghdrs),
					sizeof(msgq->msgmaps),
					sizeof(msgq->msgpool));*/

			/* Init lock. */
#ifdef SYSV_RWLOCK
			sysv_rwlock_init(&msgq->rwlock);
#else
			sysv_mutex_init(&msgq->mutex);
#endif
			/* In kernel implementation, this was done globally. */
			for (i = 0; i < msginfo.msgseg; i++) {
				if (i > 0)
					msgq->msgmaps[i-1].next = i;
				msgq->msgmaps[i].next = -1;	/* implies entry is available */
			}
			msgq->free_msgmaps = 0;
			msgq->nfree_msgmaps = msginfo.msgseg;

			for (i = 0; i < msginfo.msgtql; i++) {
				msgq->msghdrs[i].msg_type = 0;
				if (i > 0)
					msgq->msghdrs[i-1].msg_next = i;
				msgq->msghdrs[i].msg_next = -1;
			}
			msgq->free_msghdrs = 0;

			/* Credentials are kept in shmid_ds structure. */
			msgq->ds.msg_perm.seq = shmseg->shm_perm.seq;
			msgq->ds.first.msg_first_index = -1;
			msgq->ds.last.msg_last_index = -1;
			msgq->ds.msg_cbytes = 0;
			msgq->ds.msg_qnum = 0;
			msgq->ds.msg_qbytes = msginfo.msgmnb;
			msgq->ds.msg_lspid = 0;
			msgq->ds.msg_lrpid = 0;
			msgq->ds.msg_stime = 0;
			msgq->ds.msg_rtime = 0;

			munmap(addr, size);

			break;
		default:
			break;
	}

	unlink(filename);
out:
	return (fd);
error:
	close(fd);
	return (-1);
}

/* Install for the client the file corresponding to fd. */
static int
install_fd_client(pid_t pid, int fd) {
	int ret;
	struct client *cl = _hash_lookup(clientshash, pid);
	if (!cl) {
		sysvd_print_err("no client entry for pid = %d\n", pid);
		return (-1);
	}

	ret = send_fd(cl->sock, fd);
	if (ret < 0) {
		sysvd_print_err("can not send fd to client %d\n", pid);
		return (-1);
	}

	return (0);
}

static int
shm_find_segment_by_key(key_t key)
{
	int i;

	for (i = 0; i < shmalloced; i++) {
		if ((shmsegs[i].shm_perm.mode & SHMSEG_ALLOCATED) &&
				shmsegs[i].shm_perm.key == key)
			return (i);
	}
	return (-1);
}

static struct shmid_ds *
shm_find_segment_by_shmid(int shmid)
{
	int segnum;
	struct shmid_ds *shmseg;

	segnum = IPCID_TO_IX(shmid);
	if (segnum < 0 || segnum >= shmalloced) {
		sysvd_print_err("segnum out of range\n");
		return (NULL);
	}

	shmseg = &shmsegs[segnum];
	if ((shmseg->shm_perm.mode & (SHMSEG_ALLOCATED | SHMSEG_REMOVED))
			!= SHMSEG_ALLOCATED ||
			shmseg->shm_perm.seq != IPCID_TO_SEQ(shmid)) {
		sysvd_print("segment most probably removed\n");
		return (NULL);
	}
	return (shmseg);
}

/* Remove a shared memory segment. */
static void
shm_deallocate_segment(int segnum)
{
	size_t size;
	struct shmid_ds *shmseg = &shmsegs[segnum];
	struct shm_handle *internal =
		(struct shm_handle *)shmseg->shm_internal;
//	int nsems;

	sysvd_print("deallocate segment %d\n", segnum);

	size = round_page(shmseg->shm_segsz);

#if 0
	if (internal->type == SEMGET) {
			nsems = (shmseg->shm_segsz - sizeof(struct semid_pool)) /
				sizeof(struct sem);
			semtot -= nsems;
			sysvd_print("freed %d sems\n", nsems);
	}
#endif

	/* Close the corresponding file. */
	close(internal->fd);

	/* Free other resources. */
	free(shmseg->shm_internal);
	shmseg->shm_internal = NULL;
	shm_committed -= btoc(size);
	shm_nused--;

	shmseg->shm_perm.mode = SHMSEG_FREE;
}

static void *map_seg(int);
static int munmap_seg(int, void *);

/* In sem and msg case notify the other processes that use it. */
static void
mark_segment_removed(int shmid, int type) {
	struct semid_pool *semaptr;
	struct msqid_pool *msgq;

	switch (type) {
		case SEMGET:
			semaptr = (struct semid_pool *)map_seg(shmid);
#ifdef SYSV_RWLOCK
			sysv_rwlock_wrlock(&semaptr->rwlock);
#else
			sysv_mutex_lock(&semaptr->mutex);
#endif
			semaptr->gen = -1;

			/* It is not necessary to wake waiting threads because
			 * if the group of semaphores is acquired by a thread,
			 * the smaptr lock is held, so it is impossible to
			 * reach this point.
			 */
#ifdef SYSV_RWLOCK
			sysv_rwlock_unlock(&semaptr->rwlock);
#else
			sysv_mutex_unlock(&semaptr->mutex);
#endif
			munmap_seg(shmid, semaptr);
			break;
		case MSGGET :
			msgq = (struct msqid_pool*)map_seg(shmid);
#ifdef SYSV_RWLOCK
			sysv_rwlock_wrlock(&msgq->rwlock);
#else
			sysv_mutex_lock(&msgq->mutex);
#endif
			msgq->gen = -1;

#ifdef SYSV_RWLOCK
			sysv_rwlock_unlock(&msgq->rwlock);
#else
			sysv_mutex_unlock(&msgq->mutex);
#endif
			munmap_seg(shmid, msgq);
			break;
		default:
			break;
	}
}

/* Get the id of an existing shared memory segment. */
static int
shmget_existing(struct shmget_msg *shmget_msg, int mode,
		int segnum, struct cmsgcred *cred)
{
	struct shmid_ds *shmseg;
	int error;

	shmseg = &shmsegs[segnum];
	if (shmseg->shm_perm.mode & SHMSEG_REMOVED) {
		/*
		 * This segment is in the process of being allocated.  Wait
		 * until it's done, and look the key up again (in case the
		 * allocation failed or it was freed).
		 */
		//TODO Maybe it will be necessary if the daemon is multithreading
		/*shmseg->shm_perm.mode |= SHMSEG_WANTED;
		  error = tsleep((caddr_t)shmseg, PCATCH, "shmget", 0);
		  if (error)
		  return error;
		  return EAGAIN;*/
	}
	if ((shmget_msg->shmflg & (IPC_CREAT | IPC_EXCL)) == (IPC_CREAT | IPC_EXCL))
		return (-EEXIST);
	error = ipcperm(cred, &shmseg->shm_perm, mode);
	if (error)
		return (-error);
	if (shmget_msg->size && (shmget_msg->size > shmseg->shm_segsz))
		return (-EINVAL);
	return (IXSEQ_TO_IPCID(segnum, shmseg->shm_perm));
}

/* Create a shared memory segment and return the id. */
static int
shmget_allocate_segment(pid_t pid, struct shmget_msg *shmget_msg,
		int mode, struct cmsgcred *cred)
{
	int i, segnum, shmid;
	size_t size;
	struct shmid_ds *shmseg;
	struct shm_handle *handle;
#if 0
	/* It is possible after a process calls exec().
	 * We don't create another segment but return the old one
	 * with all information.
	 * This segment is destroyed only when process dies.
	 * */
	if (shmget_msg->type == UNDOGET) {
		struct client *cl= _hash_lookup(clientshash, pid);
		if (cl->undoid != -1)
			return cl->undoid;
	}
#endif
	if ((long)shmget_msg->size < shminfo.shmmin)
			//|| (long)shmget_msg->size > shminfo.shmmax)
			/* There is no need to check the max limit,
			 * the operating system do this for us.
			 */
		return (-EINVAL);
	if (shm_nused >= shminfo.shmmni) /* any shmids left? */
		return (-ENOSPC);

	/* Compute the size of the segment. */
	size = round_page(shmget_msg->size);

	/* Find a free entry in the shmsegs vector. */
	if (shm_last_free < 0) {
		//	shmrealloc();	/* maybe expand the shmsegs[] array */
		for (i = 0; i < shmalloced; i++) {
			if (shmsegs[i].shm_perm.mode & SHMSEG_FREE)
				break;
		}
		if (i == shmalloced) {
			sysvd_print("i == shmalloced\n");
			return (-ENOSPC);
		}
		segnum = i;
	} else  {
		segnum = shm_last_free;
		shm_last_free = -1;
	}
	shmseg = &shmsegs[segnum];
	/*
	 * In case we sleep in malloc(), mark the segment present but deleted
	 * so that noone else tries to create the same key.
	 */
	shmseg->shm_perm.mode = SHMSEG_ALLOCATED | SHMSEG_REMOVED;
	shmseg->shm_perm.key = shmget_msg->key;
	shmseg->shm_perm.seq = (shmseg->shm_perm.seq + 1) & 0x7fff;

	/* Create the file for the shared memory segment. */
	handle = shmseg->shm_internal = malloc(sizeof(struct shm_handle));
	handle->type = shmget_msg->type;
	handle->fd = create_sysv_file(shmget_msg, size, shmseg);
	if (handle->fd == -1) {
		free(handle);
		handle = NULL;
		shmseg->shm_perm.mode = SHMSEG_FREE;
		shm_last_free = segnum;
		errno = -ENFILE;
		return (-1);
	}

	LIST_INIT(&handle->attached_list);

	if (handle->fd < 0) {
		free(shmseg->shm_internal);
		shmseg->shm_internal = NULL;
		shm_last_free = segnum;
		shmseg->shm_perm.mode = SHMSEG_FREE;
		return (-errno);
	}

	/* Get the id. */
	shmid = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm);

	shmseg->shm_perm.cuid = shmseg->shm_perm.uid = cred->cmcred_euid;
	shmseg->shm_perm.cgid = shmseg->shm_perm.gid = cred->cmcred_gid;
	shmseg->shm_perm.mode = (shmseg->shm_perm.mode & SHMSEG_WANTED) |
		(mode & ACCESSPERMS) | SHMSEG_ALLOCATED;

	shmseg->shm_cpid = pid;
	shmseg->shm_lpid = shmseg->shm_nattch = 0;
	shmseg->shm_atime = shmseg->shm_dtime = 0;
	shmseg->shm_ctime = time(NULL);

	shmseg->shm_segsz = shmget_msg->size;
	shm_committed += btoc(size);
	shm_nused++;

	if (shmseg->shm_perm.mode & SHMSEG_WANTED) {
		/*
		 * Somebody else wanted this key while we were asleep.  Wake
		 * them up now.
		 */
		shmseg->shm_perm.mode &= ~SHMSEG_WANTED;
		//TODO multithreading
		//wakeup((caddr_t)shmseg);
	}
	shmseg->shm_perm.mode &= ~SHMSEG_REMOVED;

	if (shmget_msg->type == UNDOGET) {
		/* The file is used by daemon when clients terminates
		 * and sem_undo resources must be cleaned.
		 */
		struct client *cl= _hash_lookup(clientshash, pid);
		cl->undoid = shmid;
	}

	return (shmid);
}

/* Handle a shmget() request. */
int
handle_shmget(pid_t pid, struct shmget_msg *shmget_msg,
		struct cmsgcred *cred ) {
	int segnum, mode, error;
	struct shmid_ds *shmseg;
	struct shm_handle *handle;

	//if (!jail_sysvipc_allowed && td->td_cmsgcred->cr_prison != NULL)
	//	return (ENOSYS);
	mode = shmget_msg->shmflg & ACCESSPERMS;

	sysvd_print("ask for key = %ld\n", shmget_msg->key);
	shmget_msg->key = (shmget_msg->key & 0x3FFF) |
		(shmget_msg->type << 30);
	sysvd_print("ask for key = %ld\n", shmget_msg->key);

	if (shmget_msg->key != IPC_PRIVATE) {
		//again:
		segnum = shm_find_segment_by_key(shmget_msg->key);
		if (segnum >= 0) {
			error = shmget_existing(shmget_msg, mode, segnum, cred);
			//TODO if daemon is multithreading
			//if (error == EAGAIN)
			//	goto again;
			goto done;
		}
		if ((shmget_msg->shmflg & IPC_CREAT) == 0) {
			error = -ENOENT;
			goto done_err;
		}
	}
	error = shmget_allocate_segment(pid, shmget_msg, mode, cred);
	sysvd_print("allocate segment = %d\n", error);
done:
	/*
	 * Install to th client the file corresponding to the
	 * shared memory segment.
	 * client_fd is the file descriptor added in the client
	 * files table.
	 */
	shmseg = shm_find_segment_by_shmid(error);
	if (shmseg == NULL) {
		sysvd_print_err("can not find segment by shmid\n");
		return (-1);
	}

	handle = (struct shm_handle *)shmseg->shm_internal;
	if (install_fd_client(pid, handle->fd) != 0)
		error = errno;
done_err:
	return (error);

}

/* Handle a shmat() request. */
int
handle_shmat(pid_t pid, struct shmat_msg *shmat_msg,
		struct cmsgcred *cred ) {
	int error;
	int fd;
	struct shmid_ds *shmseg;
	struct pid_attached *pidatt;
	struct shm_handle *handle;
	size_t new_size = shmat_msg->size;
	struct client *cl;
	struct id_attached *idatt;

	/*if (!jail_sysvipc_allowed && td->td_cmsgcred->cr_prison != NULL)
	  return (ENOSYS);

again:*/
	shmseg = shm_find_segment_by_shmid(shmat_msg->shmid);
	if (shmseg == NULL) {
		sysvd_print_err("shmat error: segment was not found\n");
		error = EINVAL;
		goto done;
	}
	error = ipcperm(cred, &shmseg->shm_perm,
			(shmat_msg->shmflg & SHM_RDONLY) ? IPC_R : IPC_R|IPC_W);
	if (error)
		goto done;

	handle = shmseg->shm_internal;

	if (shmat_msg->size > shmseg->shm_segsz) {
		if (handle->type != UNDOGET) {
			error = EINVAL;
			goto done;
		}

		fd = ((struct shm_handle*)shmseg->shm_internal)->fd;
		ftruncate(fd, round_page(new_size));
		shmseg->shm_segsz = new_size;
	}

	shmseg->shm_lpid = pid;
	shmseg->shm_atime = time(NULL);

	if (handle->type != UNDOGET)
		shmseg->shm_nattch++;
	else
		shmseg->shm_nattch = 1; /* Only a process calls shmat and
		only once. If it does it for more than once that is because
		it called exec() and reinitialized the undo segment. */

	/* Insert the pid in the segment list of attaced pids.
	 * The list is checked in handle_shmdt so that only
	 * attached pids can dettached from this segment.
	 */
	sysvd_print("nattch = %d pid = %d\n",
			shmseg->shm_nattch, pid);

	pidatt = malloc(sizeof(*pidatt));
	pidatt->pid = pid;
	LIST_INSERT_HEAD(&handle->attached_list, pidatt, link);

	/* Add the segment at the list of attached segments of the client.
	 * It is used when the process finishes its execution. The daemon
	 * walks through the list to dettach the segments.
	 */
	idatt = malloc(sizeof(*idatt));
	idatt->shmid = shmat_msg->shmid;
	cl = _hash_lookup(clientshash, pid);
	LIST_INSERT_HEAD(&cl->ids_attached, idatt, link);

	return (0);
done:
	return (error);
}

/* Handle a shmdt() request. */
int
handle_shmdt(pid_t pid, int shmid) {
	struct shmid_ds *shmseg;
	int segnum;
	struct shm_handle *handle;
	struct pid_attached *pidatt;
	struct id_attached *idatt;
	struct client *cl;

	sysvd_print("shmdt pid %d shmid %d\n", pid, shmid);
	/*if (!jail_sysvipc_allowed && td->td_cmsgcred->cr_prison != NULL)
	  return (ENOSYS);
	*/

	segnum = IPCID_TO_IX(shmid);
	shmseg = &shmsegs[segnum];
	handle = shmseg->shm_internal;

	/* Check if pid is attached. */
	LIST_FOREACH(pidatt, &handle->attached_list, link)
		if (pidatt->pid == pid)
			break;
	if (!pidatt) {
		sysvd_print_err("process %d is not attached to %d (1)\n",
				pid, shmid);
		return (EINVAL);
	}
	LIST_REMOVE(pidatt, link);

	/* Remove the segment from the list of attached segments of the pid.*/
	cl = _hash_lookup(clientshash, pid);
	LIST_FOREACH(idatt, &cl->ids_attached, link)
		if (idatt->shmid == shmid)
			break;
	if (!idatt) {
		sysvd_print_err("process %d is not attached to %d (2)\n",
				pid, shmid);
		return (EINVAL);
	}
	LIST_REMOVE(idatt, link);

	shmseg->shm_dtime = time(NULL);

	/* If no other process attaced remove the segment. */
	if ((--shmseg->shm_nattch <= 0) &&
			(shmseg->shm_perm.mode & SHMSEG_REMOVED)) {
		shm_deallocate_segment(segnum);
		shm_last_free = segnum;
	}

	return (0);
}

/* Handle a shmctl() request. */
int
handle_shmctl(struct shmctl_msg *shmctl_msg,
		struct cmsgcred *cred ) {
	int error = 0;
	struct shmid_ds *shmseg, *inbuf;

	/*	if (!jail_sysvipc_allowed && td->td_cmsgcred->cr_prison != NULL)
		return (ENOSYS);
		*/
	shmseg = shm_find_segment_by_shmid(shmctl_msg->shmid);

	if (shmseg == NULL) {
		error = EINVAL;
		goto done;
	}

	switch (shmctl_msg->cmd) {
		case IPC_STAT:
			sysvd_print("IPC STAT\n");
			error = ipcperm(cred, &shmseg->shm_perm, IPC_R);
			if (error) {
				sysvd_print("IPC_STAT not allowed\n");
				break;
			}
			shmctl_msg->buf = *shmseg;
			break;
		case IPC_SET:
			sysvd_print("IPC SET\n");
			error = ipcperm(cred, &shmseg->shm_perm, IPC_M);
			if (error) {
				sysvd_print("IPC_SET not allowed\n");
				break;
			}
			inbuf = &shmctl_msg->buf;

			shmseg->shm_perm.uid = inbuf->shm_perm.uid;
			shmseg->shm_perm.gid = inbuf->shm_perm.gid;
			shmseg->shm_perm.mode =
				(shmseg->shm_perm.mode & ~ACCESSPERMS) |
				(inbuf->shm_perm.mode & ACCESSPERMS);
			shmseg->shm_ctime = time(NULL);
			break;
		case IPC_RMID:
			sysvd_print("IPC RMID shmid = %d\n",
					shmctl_msg->shmid);
			error = ipcperm(cred, &shmseg->shm_perm, IPC_M);
			if (error) {
				sysvd_print("IPC_RMID not allowed\n");
				break;
			}
			shmseg->shm_perm.key = IPC_PRIVATE;
			shmseg->shm_perm.mode |= SHMSEG_REMOVED;
			if (shmseg->shm_nattch <= 0) {
				shm_deallocate_segment(IPCID_TO_IX(shmctl_msg->shmid));
				shm_last_free = IPCID_TO_IX(shmctl_msg->shmid);
			}
			else {
				/* In sem and msg cases, other process must be
				 * noticed about the removal. */
				struct shm_handle *internal =
					(struct shm_handle *)shmseg->shm_internal;
				mark_segment_removed(shmctl_msg->shmid,
						internal->type);
			}
			break;
#if 0
		case SHM_LOCK:
		case SHM_UNLOCK:
#endif
		default:
			error = EINVAL;
			break;
	}
done:
	return (error);

}

/* Function used by daemon to map a sysv resource. */
static void *
map_seg(int shmid) {
	struct shmid_ds *shmseg;
	struct shm_handle *internal;

	int fd;
	size_t size;
	void *addr;

	shmseg = shm_find_segment_by_shmid(shmid);
	if (!shmseg) {
		sysvd_print_err("map_seg error:"
				"semid %d not found\n", shmid);
		return (NULL);
	}

	internal = (struct shm_handle *)shmseg->shm_internal;
	if (!internal) {
		sysvd_print_err("map_seg error: internal for"
				"semid %d not found\n", shmid);
		return (NULL);
	}

	fd = internal->fd;

	size = round_page(shmseg->shm_segsz);

	addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
	if (!addr) {
		sysvd_print_err("map_seg: error mmap semid = %d\n", shmid);
		return (NULL);
	}

	return (addr);
}

/* Function used by daemon to munmap a sysv resource. */
static int
munmap_seg(int shmid, void *addr) {
	struct shmid_ds *shmseg;
	struct shm_handle *internal;

	size_t size;

	shmseg = shm_find_segment_by_shmid(shmid);
	if (!shmseg) {
		sysvd_print_err("munmap_seg error:"
				"semid %d not found\n", shmid);
		return (-1);
	}

	internal = (struct shm_handle *)shmseg->shm_internal;
	if (!internal) {
		sysvd_print_err("munmap_seg error: internal for"
				"semid %d not found\n", shmid);
		return (-1);
	}

	size = round_page(shmseg->shm_segsz);
	munmap(addr, size);

	return (0);
}

void
shminit(void) {
	int i;

	shmalloced = shminfo.shmmni;
	shmsegs = malloc(shmalloced * sizeof(shmsegs[0]));
	for (i = 0; i < shmalloced; i++) {
		shmsegs[i].shm_perm.mode = SHMSEG_FREE;
		shmsegs[i].shm_perm.seq = 0;
	}
	shm_last_free = 0;
	shm_nused = 0;
	shm_committed = 0;

	/*
	 * msginfo.msgssz should be a power of two for efficiency reasons.
	 * It is also pretty silly if msginfo.msgssz is less than 8
	 * or greater than about 256 so ...
	 */
	i = 8;
	while (i < 1024 && i != msginfo.msgssz)
		i <<= 1;
	if (i != msginfo.msgssz) {
		sysvd_print_err("msginfo.msgssz=%d (0x%x)\n", msginfo.msgssz,
		    msginfo.msgssz);
		sysvd_print_err("msginfo.msgssz not a small power of 2");
		exit(-1);
	}
	msginfo.msgmax = msginfo.msgseg * msginfo.msgssz;
}

/*static void
shmfree(void) {
	free(shmsegs);
}*/

int
semexit(int undoid) {
	struct sem_undo *suptr;
	struct sem *semptr;
	struct shmid_ds *undoseg;

	if (undoid < 0) {
		return (-1);
	}

	undoseg = shm_find_segment_by_shmid(undoid);
	/* The UNDO segment must be mapped by only one segment. */
	if (undoseg->shm_nattch != 1) {
		sysvd_print_err("undo segment mapped by more"
				"than one process\n");
		exit(-1);
	}

	suptr = (struct sem_undo *)map_seg(undoid);
	if (suptr == NULL) {
		sysvd_print_err("no %d undo segment found\n", undoid);
		return (-1);
	}

	/* No locking mechanism is required because only the
	 * client and the daemon can access the UNDO segment.
	 * At this moment the client is disconnected so only
	 * the daemon can modify this segment.
	 */
	while (suptr->un_cnt) {
		struct semid_pool *semaptr;
		int semid;
		int semnum;
		int adjval;
		int ix;

		ix = suptr->un_cnt - 1;
		semid = suptr->un_ent[ix].un_id;
		semnum = suptr->un_ent[ix].un_num;
		adjval = suptr->un_ent[ix].un_adjval;

		semaptr = (struct semid_pool *)map_seg(semid);
		if (!semaptr) {
			return (-1);
		}

		/* Was it removed? */
		if (semaptr->gen == -1 ||
			semaptr->ds.sem_perm.seq != IPCID_TO_SEQ(semid) ||
			(semaptr->ds.sem_perm.mode & SHMSEG_ALLOCATED) == 0) {
			--suptr->un_cnt;
			sysvd_print_err("semexit - semid not allocated\n");
			continue;
		}
		if (semnum >= semaptr->ds.sem_nsems) {
			--suptr->un_cnt;
			sysvd_print_err("semexit - semnum out of range\n");
			continue;
		}

#ifdef SYSV_RWLOCK
#ifdef SYSV_SEMS
		sysv_rwlock_rdlock(&semaptr->rwlock);
#else
		sysv_rwlock_wrlock(&semaptr->rwlock);
#endif //SYSV_SEMS
#else
		sysv_mutex_lock(&semaptr->mutex);
		/* Nobody can remove the semaphore beteen the check and the
		 * lock acquisition because it must first send a IPC_RMID
		 * to me and I will process that after finishing this function.
		 */
#endif //SYSV_RWLOCK
		semptr = &semaptr->ds.sem_base[semnum];
#ifdef SYSV_SEMS
		sysv_mutex_lock(&semptr->sem_mutex);
#endif
		if (ix == suptr->un_cnt - 1 &&
		    semid == suptr->un_ent[ix].un_id &&
		    semnum == suptr->un_ent[ix].un_num &&
		    adjval == suptr->un_ent[ix].un_adjval) {
			--suptr->un_cnt;

			if (adjval < 0) {
				if (semptr->semval < -adjval)
					semptr->semval = 0;
				else
					semptr->semval += adjval;
			} else {
				semptr->semval += adjval;
			}
			/* TODO multithreaded daemon:
			 * Check again if the semaphore was removed and do
			 * not wake anyone if it was.*/
			umtx_wakeup((int *)&semptr->semval, 0);
		}
#ifdef SYSV_SEMS
		sysv_mutex_unlock(&semptr->sem_mutex);
#endif

#ifdef SYSV_RWLOCK
		sysv_rwlock_unlock(&semaptr->rwlock);
#else
		sysv_mutex_unlock(&semaptr->mutex);
#endif
		munmap_seg(semid, semaptr);
	}

	munmap_seg(undoid, suptr);
	return (0);
}

void
shmexit(struct client *cl) {
	struct id_attached *idatt;

	while (!LIST_EMPTY(&cl->ids_attached)) {
		idatt = LIST_FIRST(&cl->ids_attached);
		handle_shmdt(cl->pid, idatt->shmid);
	}
}