/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef	_SYS_CONTRACT_IMPL_H
#define	_SYS_CONTRACT_IMPL_H

#include <sys/types.h>
#include <sys/list.h>
#include <sys/poll.h>
#include <sys/condvar.h>
#include <sys/contract.h>
#include <sys/model.h>
#include <sys/cred.h>
#include <sys/mutex.h>
#include <sys/list.h>
#include <sys/avl.h>
#include <sys/nvpair.h>
#include <sys/time.h>
#include <sys/vnode.h>
#include <sys/vfs.h>
#include <sys/zone.h>
#include <sys/project.h>

#ifdef	__cplusplus
extern "C" {
#endif

extern int ct_debug;

#define	CT_DEBUG(args)	if (ct_debug) cmn_err args

#ifdef _SYSCALL32

/*
 * 32-bit versions of the event, status and parameter structures, for use
 * (only) by the 64-bit kernel.  See sys/contract.h for the normal versions.
 * Use pack(4) to get offsets and structure size correct on amd64.
 */

#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
#pragma pack(4)
#endif

typedef struct ct_event32 {
	ctid_t	ctev_id;
	uint32_t ctev_pad1;
	ctevid_t ctev_evid;
	ct_typeid_t ctev_cttype;
	uint32_t ctev_flags;
	uint32_t ctev_type;
	uint32_t ctev_nbytes;
	uint32_t ctev_goffset;
	uint32_t ctev_pad2;
	caddr32_t ctev_buffer;
} ct_event32_t;

typedef struct ct_status32 {
	ctid_t	ctst_id;
	zoneid_t ctst_zoneid;
	ct_typeid_t ctst_type;
	pid_t	ctst_holder;
	ctstate_t ctst_state;
	int	ctst_nevents;
	int	ctst_ntime;
	int	ctst_qtime;
	uint64_t ctst_nevid;
	uint_t	ctst_detail;
	uint_t	ctst_nbytes;
	uint_t	ctst_critical;
	uint_t	ctst_informative;
	uint64_t ctst_cookie;
	caddr32_t ctst_buffer;
} ct_status32_t;

typedef struct ct_param32 {
	uint32_t  ctpm_id;
	uint32_t  ctpm_size;
	caddr32_t ctpm_value;
} ct_param32_t;

#if _LONG_LONG_ALIGNMENT == 8 && _LONG_LONG_ALIGNMENT_32 == 4
#pragma pack()
#endif

#endif /* _SYSCALL32 */

/*
 * in kernel version of parameter structure.
 */
typedef struct ct_kparam {
	ct_param_t	param;		/* copy of user ct_param_t */
	void		*ctpm_kbuf;	/* kernel buffer for parameter value */
	uint32_t	ret_size;	/* parameter value size for copyout */
} ct_kparam_t;

struct proc;

/*
 * Contract template ops vector
 */
typedef struct ctmplops {
	struct ct_template	*(*ctop_dup)(struct ct_template *);
	void		(*ctop_free)(struct ct_template *);
	int		(*ctop_set)(struct ct_template *, ct_kparam_t *,
			const cred_t *);
	int		(*ctop_get)(struct ct_template *, ct_kparam_t *);
	int		(*ctop_create)(struct ct_template *, ctid_t *);
	uint_t		allevents;
} ctmplops_t;

/*
 * Contract template
 */
typedef struct ct_template {
	kmutex_t	ctmpl_lock;
	ctmplops_t	*ctmpl_ops;
	struct ct_type	*ctmpl_type;
	void		*ctmpl_data;
	uint64_t	ctmpl_cookie;	/* term: contract cookie */
	uint_t		ctmpl_ev_crit;	/* term: critical events */
	uint_t		ctmpl_ev_info;	/* term: informative events */
} ct_template_t;


typedef enum ct_listnum {
	CTEL_CONTRACT,			/* ../contracts/type/<id>/events */
	CTEL_BUNDLE,			/* ../contracts/type/bundle */
	CTEL_PBUNDLE,			/* ../contracts/type/pbundle */
	CTEL_MAX
} ct_listnum_t;

typedef enum ctqflags {
	CTQ_DEAD = 1,	/* contract explicitly cancelled */
	CTQ_REFFED = 2	/* queue is reference counted */
} ctqflags_t;

typedef enum ct_ack {
	CT_ACK = 1,	/* accept break */
	CT_NACK,	/* disallow break */
	CT_NONE		/* no matching contracts */
} ct_ack_t;

/*
 * Contract event queue
 */
typedef struct ct_equeue {
	kmutex_t ctq_lock;
	timespec_t ctq_atime;		/* access time */
	ct_listnum_t ctq_listno;	/* which list node */
	list_t	ctq_events;		/* list of events */
	list_t	ctq_listeners;		/* list of all listeners */
	list_t	ctq_tail;		/* list of tail listeners */
	int	ctq_nlisteners;		/* number of listeners */
	int	ctq_nreliable;		/* number of reliable listeners */
	int	ctq_ninf;		/* number of informative events */
	int	ctq_max;		/* max informative events */
	ctqflags_t ctq_flags;		/* queue flags */
} ct_equeue_t;

typedef struct ct_member {
	list_node_t	ctm_node;	/* list membership */
	int		ctm_refs;	/* number of references per list */
	int		ctm_trimmed;	/* membership has been trimmed */
	int		ctm_nreliable;	/* reliable listeners */
} ct_member_t;

typedef struct ct_kevent {
	kmutex_t	cte_lock;
	uint64_t	cte_id;		/* event id */
	uint_t		cte_type;	/* event type */
	int		cte_refs;
	ct_member_t	cte_nodes[CTEL_MAX]; /* event queue membership */
	int		cte_flags;	/* see above */
	nvlist_t 	*cte_data;	/* event data */
	nvlist_t 	*cte_gdata;	/* global-zone only data */

	struct contract	*cte_contract;	/* contract */
} ct_kevent_t;

/*
 * Contract vnode linkage.
 * Avoid having too much knowledge about the FS.
 */
typedef struct contract_vnode {
	list_node_t	ctv_node;
	vnode_t		*ctv_vnode;
} contract_vnode_t;

/*
 * Contract ops vector
 *   free - when reference count drops to zero
 *   abandon - when holding process dies or relinquishes interest
 *   destroy - when contract is to be completely destroyed
 *   status - when contractfs needs to return detailed status information
 */
typedef struct contops {
	void	(*contop_free)(struct contract *);
	void	(*contop_abandon)(struct contract *);
	void	(*contop_destroy)(struct contract *);
	void	(*contop_status)(struct contract *, zone_t *, int, nvlist_t *,
	    void *, model_t);
	int	(*contop_ack)(struct contract *, uint_t evtype,
	    uint64_t evid);
	int	(*contop_nack)(struct contract *, uint_t evtype,
	    uint64_t evid);
	int	(*contop_qack)(struct contract *, uint_t, uint64_t);
	int	(*contop_newct)(struct contract *);
} contops_t;

typedef ct_template_t *(ct_f_default_t)(void);

/*
 * Contract type information.
 */
typedef struct ct_type {
	uint64_t	ct_type_evid;	/* last event id */
	ct_typeid_t	ct_type_index;	/* index in ct_types array */
	const char	*ct_type_name;	/* type as a string */
	kmutex_t	ct_type_lock;	/* protects ct_type_avl */
	avl_tree_t	ct_type_avl;	/* ordered list of type contracts */
	timestruc_t	ct_type_timestruc; /* time last contract was written */
	ct_equeue_t	ct_type_events;	/* bundle queue */
	contops_t	*ct_type_ops;
	ct_f_default_t	*ct_type_default; /* creates a fresh template */
} ct_type_t;

typedef enum ctflags {
	CTF_INHERIT = 0x1
} ctflags_t;

typedef struct ct_time {
	long	ctm_total;	/* Total time allowed for event */
	clock_t	ctm_start;	/* starting lbolt for event */
} ct_time_t;

/*
 * Contract
 */
typedef struct contract {
	uint64_t	ct_ref;		/* reference count */
	kmutex_t	ct_reflock;	/* reference count lock */
	kmutex_t	ct_evtlock;	/* event dispatch lock */

					/* Static data */
	kproject_t	*ct_proj;	/* project of creator */
	uid_t		ct_cuid;	/* uid of contract author */
	zoneid_t	ct_zoneid;	/* zoneid of creator */
	uint64_t	ct_czuniqid;	/* unique id of creator's zone */
	timespec_t	ct_ctime;	/* creation time */
	ct_type_t	*ct_type;	/* contract type information */
	void		*ct_data;	/* contract type data */
	ctid_t		ct_id;		/* contract ID */
	uint64_t	ct_cookie;	/* term: contract cookie */
	uint_t		ct_ev_crit;	/* term: critical events */
	uint_t		ct_ev_info;	/* term: informative events */

					/* Protected by other locks */
	uint64_t	ct_mzuniqid;	/* unique id of members' zone */
	avl_node_t	ct_ctavl;	/* avl membership */
	avl_node_t	ct_cttavl;	/* type avl membership */
	avl_node_t	ct_ctlist;	/* position in holder's list */

	kmutex_t	ct_lock;	/* lock for everything below */
	ctstate_t	ct_state;	/* contract's state */
	list_t		ct_vnodes;	/* vnodes list */
	ctflags_t	ct_flags;	/* contract flags */
	ct_equeue_t	ct_events;	/* contract event queue */
	struct proc	*ct_owner;	/* contract owner (if owned) */
	struct contract	*ct_regent;	/* [prospective] regent contract */
	int		ct_evcnt;	/* number of critical events */
	ct_kevent_t	*ct_nevent;	/* negotiation event */
	ct_time_t	ct_ntime;	/* negotiation time tracker */
	ct_time_t	ct_qtime;	/* quantum time tracker */
} contract_t;

#define	CTLF_COPYOUT	0x1		/* performing copyout */
#define	CTLF_RESET	0x2		/* event pointer reset or moved */
#define	CTLF_DEAD	0x4		/* dead listener */
#define	CTLF_RELIABLE	0x8		/* reliable listener */
#define	CTLF_CRITICAL	0x10		/* waiting for critical event */

typedef struct ct_listener {
	list_node_t	ctl_allnode;	/* entry in list of all listeners */
	list_node_t	ctl_tailnode;	/* entry in list of tail listeners */
	ct_equeue_t	*ctl_equeue;	/* queue */
	ct_kevent_t	*ctl_position;	/* position in queue */
	int		ctl_flags;	/* state flags */
	kcondvar_t	ctl_cv;		/* for waiting for an event */
	pollhead_t	ctl_pollhead;	/* so we can poll(2) */
} ct_listener_t;

/*
 * Contract template interfaces
 */
void ctmpl_free(ct_template_t *);
int ctmpl_set(ct_template_t *, ct_kparam_t *, const cred_t *);
int ctmpl_get(ct_template_t *, ct_kparam_t *);
ct_template_t *ctmpl_dup(ct_template_t *);
void ctmpl_activate(ct_template_t *);
void ctmpl_clear(ct_template_t *);
int ctmpl_create(ct_template_t *, ctid_t *);

/*
 * Contract parameter functions
 */
int ctparam_copyin(const void *, ct_kparam_t *, int, int);
int ctparam_copyout(ct_kparam_t *, void *, int);

/*
 * Contract functions
 */
void contract_init(void);
int contract_abandon(contract_t *, struct proc *, int);
int contract_adopt(contract_t *, struct proc *);
void contract_destroy(contract_t *);
void contract_exit(struct proc *);
int contract_ack(contract_t *ct, uint64_t evid, int cmd);
int contract_qack(contract_t *ct, uint64_t evid);
int contract_newct(contract_t *ct);

/*
 * Event interfaces
 */
uint64_t cte_publish_all(contract_t *, ct_kevent_t *, nvlist_t *, nvlist_t *);
void cte_add_listener(ct_equeue_t *, ct_listener_t *);
void cte_remove_listener(ct_listener_t *);
void cte_reset_listener(ct_listener_t *);
int cte_get_event(ct_listener_t *, int, void *, const cred_t *, uint64_t, int);
int cte_next_event(ct_listener_t *, uint64_t);
int cte_set_reliable(ct_listener_t *, const cred_t *);

/*
 * Contract implementation interfaces
 */
int contract_compar(const void *, const void *);
void ctmpl_init(ct_template_t *, ctmplops_t *, ct_type_t *, void *);
void ctmpl_copy(ct_template_t *, ct_template_t *);
int ctmpl_create_inval(ct_template_t *, ctid_t *);
int contract_ctor(contract_t *, ct_type_t *, ct_template_t *, void *, ctflags_t,
    struct proc *, int);
void contract_hold(contract_t *);
void contract_rele(contract_t *);
uint64_t contract_getzuniqid(contract_t *);
void contract_setzuniqid(contract_t *, uint64_t);
void contract_rele_unlocked(contract_t *);
void contract_status_common(contract_t *, zone_t *, void *, model_t);
void contract_orphan(contract_t *);
ctid_t contract_lookup(uint64_t, ctid_t);
ctid_t contract_plookup(struct proc *, ctid_t, uint64_t);
contract_t *contract_ptr(id_t, uint64_t);
ctid_t contract_max(void);
int contract_owned(contract_t *, const cred_t *, int);

/*
 * Type interfaces
 */
extern int ct_ntypes;
extern ct_type_t **ct_types;

ct_type_t *contract_type_init(ct_typeid_t, const char *, contops_t *,
    ct_f_default_t *);
int contract_type_count(ct_type_t *);
ctid_t contract_type_max(ct_type_t *);
ctid_t contract_type_lookup(ct_type_t *, uint64_t, ctid_t);
contract_t *contract_type_ptr(ct_type_t *, ctid_t, uint64_t);
void contract_type_time(ct_type_t *, timestruc_t *);
ct_equeue_t *contract_type_bundle(ct_type_t *);
ct_equeue_t *contract_type_pbundle(ct_type_t *, struct proc *);

/*
 * FS interfaces
 */
vnode_t *contract_vnode_get(contract_t *, vfs_t *);
void contract_vnode_set(contract_t *, contract_vnode_t *, vnode_t *);
int contract_vnode_clear(contract_t *, contract_vnode_t *);

/*
 * Negotiation stubs
 */
int contract_ack_inval(contract_t *, uint_t, uint64_t);
int contract_qack_inval(contract_t *, uint_t, uint64_t);
int contract_qack_notsup(contract_t *, uint_t, uint64_t);

#ifdef	__cplusplus
}
#endif

#endif	/* _SYS_CONTRACT_IMPL_H */