/*
 * 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 (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#ifndef	_IPC_IMPL_H
#define	_IPC_IMPL_H

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/mutex.h>
#include <sys/ipc_rctl.h>
#include <sys/project.h>
#include <sys/zone.h>
#include <sys/sysmacros.h>
#include <sys/avl.h>
#include <sys/id_space.h>
#include <sys/cred.h>
#include <sys/list.h>

#ifdef	__cplusplus
extern "C" {
#endif

typedef uint64_t ipc_time_t;

/* For xxxctl64 */
#define	IPC_SET64	13	/* set options */
#define	IPC_STAT64	14	/* get options */

/*
 * There are two versions of the userland ipc_perm structure:
 *   ipc_perm     - the version used by user applications and by the kernel
 *		    when the user and kernel data models match (in ipc.h)
 *   ipc_perm32   - the 64-bit kernel's view of a 32-bit struct ipc_perm
 */
#if	defined(_SYSCALL32)
struct ipc_perm32 {
	uid32_t		uid;	/* owner's user id */
	gid32_t		gid;	/* owner's group id */
	uid32_t		cuid;	/* creator's user id */
	gid32_t		cgid;	/* creator's group id */
	mode32_t	mode;	/* access modes */
	uint32_t	seq;	/* slot usage sequence number */
	key32_t		key;	/* key */
	int32_t		pad[4];	/* reserve area */
};
#endif	/* _SYSCALL32 */

/*
 * This is the ipc_perm equivalent used in the xxxid_ds64 structures.
 * It, like the structures it is used in, is intended only for use in
 * communication between the kernel and user programs, and has the same
 * layout across all data models.
 *
 * The xxxid_ds64 structures rely on ipc_perm64 being a multiple of
 * 8 bytes so subsequent fields are 64-bit aligned on x86.
 */
typedef struct ipc_perm64 {
	uid_t	ipcx_uid;	/* owner's user id */
	gid_t	ipcx_gid;	/* owner's group id */
	uid_t	ipcx_cuid;	/* creator's user id */
	gid_t	ipcx_cgid;	/* creator's group id */
	mode_t	ipcx_mode;	/* access modes */
	key_t	ipcx_key;	/* key */
	projid_t ipcx_projid;	/* allocating project id */
	zoneid_t ipcx_zoneid;	/* creator's zone id */
} ipc_perm64_t;

/*
 * These are versions of xxxid_ds which are intended only for use in
 * communication between the kernel and user programs, and therefore
 * have the same layout across all data models.  Omitted are all
 * implementation-specific fields which would be of no use to user
 * programs.
 */
struct shmid_ds64 {
	ipc_perm64_t	shmx_perm;	/* operation permission struct */
	pid_t		shmx_lpid;	/* pid of last shmop */
	pid_t		shmx_cpid;	/* pid of creator */
	uint64_t	shmx_segsz;	/* size of segment in bytes */
	uint64_t	shmx_nattch;	/* # of attaches */
	uint64_t	shmx_cnattch;	/* # of ISM attaches */
	uint64_t	shmx_lkcnt;	/* lock count ??? */
	ipc_time_t	shmx_atime;	/* last shmat time */
	ipc_time_t	shmx_dtime;	/* last shmdt time */
	ipc_time_t	shmx_ctime;	/* last change time */
};

struct semid_ds64 {
	ipc_perm64_t	semx_perm;	/* operation permission struct */
	ushort_t	semx_nsems;	/* # of semaphores in set */
	ushort_t	_semx_pad[3];	/* pad to 8-byte multiple */
	ipc_time_t	semx_otime;	/* last semop time */
	ipc_time_t	semx_ctime;	/* last change time */
};

struct msqid_ds64 {
	ipc_perm64_t	msgx_perm;	/* operation permission struct */
	uint64_t	msgx_cbytes;	/* current # bytes on q */
	uint64_t	msgx_qnum;	/* # of messages on q */
	uint64_t	msgx_qbytes;	/* max # of bytes on q */
	pid_t		msgx_lspid;	/* pid of last msgsnd */
	pid_t		msgx_lrpid;	/* pid of last msgrcv */
	ipc_time_t	msgx_stime;	/* last msgsnd time */
	ipc_time_t	msgx_rtime;	/* last msgrcv time */
	ipc_time_t	msgx_ctime;	/* last change time */
};

#ifdef _KERNEL

/*
 * Implementation macros
 */
#define	IPC_FREE(x)	(((x)->ipc_mode & IPC_ALLOC) == 0)

#define	IPC_SEQ_BITS	7
#define	IPC_SEQ_MASK	((1 << IPC_SEQ_BITS) - 1)
#define	IPC_SEQ_SHIFT	(31 - IPC_SEQ_BITS)
#define	IPC_INDEX_MASK	((1 << IPC_SEQ_SHIFT) - 1)
#define	IPC_SEQ(x)	((unsigned int)(x) >> IPC_SEQ_SHIFT)
#define	IPC_INDEX(x)	((unsigned int)(x) & IPC_INDEX_MASK)

#define	IPC_IDS_MIN	(PAGESIZE / 64)		/* starting # of entries */
#define	IPC_IDS_MAX	(1 << IPC_SEQ_SHIFT)	/* maximum # of entries */
#define	IPC_ID_INVAL	UINT_MAX

#define	IPC_PROJ_USAGE(p, s) \
	(*(rctl_qty_t *)(((char *)&p->ipc_proj->kpj_data.kpd_ipc) + \
	s->ipcs_rctlofs))
#define	IPC_ZONE_USAGE(p, s) \
	(*(rctl_qty_t *)(((char *)&p->ipc_zone_ref.zref_zone->zone_ipc) + \
	s->ipcs_rctlofs))
#define	IPC_LOCKED(s, o) \
	MUTEX_HELD(&s->ipcs_table[IPC_INDEX(o->ipc_id)].ipct_lock)

/*
 * The kernel's ipc_perm structure.
 */
typedef struct kipc_perm {
	avl_node_t ipc_avl;	/* avl node if key is non-private */
	list_node_t ipc_list;	/* list node in list of all ids */
	uint_t	ipc_ref;	/* reference count		*/
	uid_t	ipc_uid;	/* owner's user id		*/
	gid_t	ipc_gid;	/* owner's group id		*/
	uid_t	ipc_cuid;	/* creator's user id		*/
	gid_t	ipc_cgid;	/* creator's group id		*/
	mode_t	ipc_mode;	/* access modes			*/
	key_t	ipc_key;	/* key				*/
	kproject_t *ipc_proj;	/* creator's project		*/
	uint_t	ipc_id;		/* id				*/
	zoneid_t ipc_zoneid;	/* creator's zone id		*/
	zone_ref_t ipc_zone_ref; /* reference to creator's zone */
} kipc_perm_t;

typedef struct ipc_slot {
	kmutex_t	ipct_lock;	/* bucket lock		*/
	kipc_perm_t	*ipct_data;	/* data			*/
	uint_t		ipct_seq;	/* sequence number	*/
	struct ipc_slot	*ipct_chain;	/* for stale arrays	*/
	char		ipct_pad[64 - sizeof (kmutex_t) - 3 * sizeof (void *)];
} ipc_slot_t;

typedef void(ipc_func_t)(kipc_perm_t *);

typedef struct ipc_service {
	kmutex_t	ipcs_lock;	/* lock for (de)allocation, keys */
	avl_tree_t	ipcs_keys;	/* objects sorted by key	*/
	ipc_slot_t	*ipcs_table;	/* table of objects		*/
	uint_t		ipcs_tabsz;	/* size of table		*/
	uint_t		ipcs_count;	/* # of objects allocated	*/
	rctl_hndl_t	ipcs_proj_rctl;	/* id limiting rctl handle	*/
	rctl_hndl_t	ipcs_zone_rctl;	/* id limiting rctl handle	*/
	size_t		ipcs_rctlofs;	/* offset in kproject_data_t	*/
	id_space_t	*ipcs_ids;	/* id space for objects		*/
	size_t		ipcs_ssize;	/* object size (for allocation)	*/
	ipc_func_t	*ipcs_dtor;	/* object destructor		*/
	ipc_func_t	*ipcs_rmid;	/* object removal		*/
	list_t		ipcs_usedids;	/* list of allocated ids	*/
	int		ipcs_atype;	/* audit type (see c2/audit.h)	*/
} ipc_service_t;

int ipcperm_access(kipc_perm_t *, int, cred_t *);
int ipcperm_set(ipc_service_t *, struct cred *, kipc_perm_t *,
    struct ipc_perm *, model_t);
void ipcperm_stat(struct ipc_perm *, kipc_perm_t *, model_t);
int ipcperm_set64(ipc_service_t *, struct cred *, kipc_perm_t *,
    ipc_perm64_t *);
void ipcperm_stat64(ipc_perm64_t *, kipc_perm_t *);

ipc_service_t *ipcs_create(const char *, rctl_hndl_t, rctl_hndl_t, size_t,
    ipc_func_t *, ipc_func_t *, int, size_t);
void ipcs_destroy(ipc_service_t *);
void ipcs_lock(ipc_service_t *);
void ipcs_unlock(ipc_service_t *);

kmutex_t *ipc_lock(ipc_service_t *, int);
kmutex_t *ipc_relock(ipc_service_t *, int, kmutex_t *);
kmutex_t *ipc_lookup(ipc_service_t *, int, kipc_perm_t **);

void ipc_hold(ipc_service_t *, kipc_perm_t *);
void ipc_rele(ipc_service_t *, kipc_perm_t *);
void ipc_rele_locked(ipc_service_t *, kipc_perm_t *);

int ipc_get(ipc_service_t *, key_t, int, kipc_perm_t **, kmutex_t **);
int ipc_commit_begin(ipc_service_t *, key_t, int, kipc_perm_t *);
kmutex_t *ipc_commit_end(ipc_service_t *, kipc_perm_t *);
void ipc_cleanup(ipc_service_t *, kipc_perm_t *);

int ipc_rmid(ipc_service_t *, int, cred_t *);
int ipc_ids(ipc_service_t *, int *, uint_t, uint_t *);

void ipc_remove_zone(ipc_service_t *, zoneid_t);

#else	/* _KERNEL */

int msgctl64(int, int, struct msqid_ds64 *);
int semctl64(int, int, int, ...);
int shmctl64(int, int, struct shmid_ds64 *);

#endif	/* _KERNEL */


#ifdef	__cplusplus
}
#endif

#endif	/* _IPC_IMPL_H */