#ifndef _IPC_H
#define _IPC_H

#include <minix/ipcconst.h>
#include <minix/type.h>
#include <minix/const.h>
#include <sys/signal.h>
#include <sys/types.h>

/*==========================================================================* 
 * Types relating to messages. 						    *
 *==========================================================================*/ 

#define M_PATH_STRING_MAX  40

typedef struct {
	uint8_t data[56];
} mess_u8;
_ASSERT_MSG_SIZE(mess_u8);

typedef struct {
	uint16_t data[28];
} mess_u16;
_ASSERT_MSG_SIZE(mess_u16);

typedef struct {
	uint32_t data[14];
} mess_u32;
_ASSERT_MSG_SIZE(mess_u32);

typedef struct {
	uint64_t data[7];
} mess_u64;
_ASSERT_MSG_SIZE(mess_u64);

typedef struct {
	uint64_t m1ull1;
	int m1i1, m1i2, m1i3;
	char *m1p1, *m1p2, *m1p3, *m1p4;
	uint8_t padding[20];
} mess_1;
_ASSERT_MSG_SIZE(mess_1);

typedef struct {
	int64_t m2ll1;
	int m2i1, m2i2, m2i3;
	long m2l1, m2l2;
	char *m2p1;
	sigset_t sigset;
	short m2s1;
	uint8_t padding[6];
} mess_2;
_ASSERT_MSG_SIZE(mess_2);

typedef struct {
	int m3i1, m3i2;
	char *m3p1;
	char m3ca1[44];
} mess_3;
_ASSERT_MSG_SIZE(mess_3);

typedef struct {
	int64_t m4ll1;
	long m4l1, m4l2, m4l3, m4l4, m4l5;
	uint8_t padding[28];
} mess_4;
_ASSERT_MSG_SIZE(mess_4);

typedef struct {
	int m7i1, m7i2, m7i3, m7i4, m7i5;
	char *m7p1, *m7p2;
	uint8_t padding[28];
} mess_7;
_ASSERT_MSG_SIZE(mess_7);

typedef struct {
	uint64_t m9ull1, m9ull2;
	long m9l1, m9l2, m9l3, m9l4, m9l5;
	short m9s1, m9s2, m9s3, m9s4;
	uint8_t padding[12];
} mess_9;
_ASSERT_MSG_SIZE(mess_9);

typedef struct {
	u64_t m10ull1;
	int m10i1, m10i2, m10i3, m10i4;
	long m10l1, m10l2, m10l3;
	uint8_t padding[20];
} mess_10;
_ASSERT_MSG_SIZE(mess_10);

/* Helper union for DS messages */
union	ds_val {
	cp_grant_id_t	grant;
	u32_t		u32;
	endpoint_t	ep;
};

typedef struct {
	union	ds_val 	val_out;
	int	val_len;
	uint8_t padding[48];
} mess_ds_reply;
_ASSERT_MSG_SIZE(mess_ds_reply);

typedef struct {
	cp_grant_id_t	key_grant;
	int		key_len;
	int		flags;
	union ds_val 	val_in;
	int		val_len;
	endpoint_t	owner;
	uint8_t padding[32];
} mess_ds_req;
_ASSERT_MSG_SIZE(mess_ds_req);

typedef struct {
	off_t seek_pos;

	size_t nbytes;

	uint8_t data[44];
} mess_fs_vfs_breadwrite;
_ASSERT_MSG_SIZE(mess_fs_vfs_breadwrite);

typedef struct {
	mode_t mode;

	uint8_t data[52];
} mess_fs_vfs_chmod;
_ASSERT_MSG_SIZE(mess_fs_vfs_chmod);

typedef struct {
	mode_t mode;

	uint8_t data[52];
} mess_fs_vfs_chown;
_ASSERT_MSG_SIZE(mess_fs_vfs_chown);

typedef struct {
	off_t file_size;
	ino_t inode;

	mode_t mode;
	uid_t uid;
	gid_t gid;

	uint8_t data[28];
} mess_fs_vfs_create;
_ASSERT_MSG_SIZE(mess_fs_vfs_create);

typedef struct {
	off_t seek_pos;

	size_t nbytes;

	uint8_t data[44];
} mess_fs_vfs_getdents;
_ASSERT_MSG_SIZE(mess_fs_vfs_getdents);

typedef struct {
	off_t offset;
	off_t file_size;
	dev_t device;
	ino_t inode;

	mode_t mode;
	uid_t uid;
	gid_t gid;

	uint16_t symloop;

	uint8_t data[10];
} mess_fs_vfs_lookup;
_ASSERT_MSG_SIZE(mess_fs_vfs_lookup);

typedef struct {
	off_t file_size;
	dev_t device;
	ino_t inode;

	mode_t mode;
	uid_t uid;
	gid_t gid;

	uint8_t data[20];
} mess_fs_vfs_newnode;
_ASSERT_MSG_SIZE(mess_fs_vfs_newnode);

typedef struct {
	size_t nbytes;

	uint8_t data[52];
} mess_fs_vfs_rdlink;
_ASSERT_MSG_SIZE(mess_fs_vfs_rdlink);

typedef struct {
	off_t file_size;
	dev_t device;
	ino_t inode;

	uint32_t flags;
	mode_t mode;
	uid_t uid;
	gid_t gid;

	uint16_t con_reqs;

	uint8_t data[14];
} mess_fs_vfs_readsuper;
_ASSERT_MSG_SIZE(mess_fs_vfs_readsuper);

typedef struct {
	off_t seek_pos;

	size_t nbytes;

	uint8_t data[44];
} mess_fs_vfs_readwrite;
_ASSERT_MSG_SIZE(mess_fs_vfs_readwrite);

typedef struct {
	uint8_t padding[56];
} mess_i2c_li2cdriver_busc_i2c_exec;
_ASSERT_MSG_SIZE(mess_i2c_li2cdriver_busc_i2c_exec);

typedef struct {
	uint8_t padding[56];
} mess_i2c_li2cdriver_busc_i2c_reserve;
_ASSERT_MSG_SIZE(mess_i2c_li2cdriver_busc_i2c_reserve);

typedef struct {
	int kbd_id;
	int mouse_id;
	int rsvd1_id;
	int rsvd2_id;

	uint8_t padding[40];
} mess_input_linputdriver_input_conf;
_ASSERT_MSG_SIZE(mess_input_linputdriver_input_conf);

typedef struct {
	uint32_t led_mask;

	uint8_t padding[52];
} mess_input_linputdriver_setleds;
_ASSERT_MSG_SIZE(mess_input_linputdriver_setleds);

typedef struct {
	int id;
	int page;
	int code;
	int value;
	int flags;

	uint8_t padding[36];
} mess_input_tty_event;
_ASSERT_MSG_SIZE(mess_input_tty_event);

typedef struct {
	time_t acnt_queue;

	unsigned long acnt_deqs;
	unsigned long acnt_ipc_sync;
	unsigned long acnt_ipc_async;
	unsigned long acnt_preempt;
	uint32_t acnt_cpu;
	uint32_t acnt_cpu_load;

	uint8_t padding[24];
} mess_krn_lsys_schedule;
_ASSERT_MSG_SIZE(mess_krn_lsys_schedule);

typedef struct {
	uint32_t value;

	uint8_t padding[52];
} mess_krn_lsys_sys_devio;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_devio);

typedef struct {
	endpoint_t endpt;
	vir_bytes msgaddr;

	uint8_t padding[48];
} mess_krn_lsys_sys_fork;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_fork);

typedef struct {
	endpoint_t endpt;
	int privflags;
	int initflags;
	char name[44];

} mess_krn_lsys_sys_getwhoami;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_getwhoami);

typedef struct {
	int hook_id;

	uint8_t padding[52];
} mess_krn_lsys_sys_irqctl;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_irqctl);

typedef struct {
	clock_t real_ticks;
	clock_t boot_ticks;
	clock_t user_time;
	clock_t system_time;
	time_t boot_time;

	uint8_t padding[32];
} mess_krn_lsys_sys_times;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_times);

typedef struct {
	long int data;

	uint8_t padding[52];
} mess_krn_lsys_sys_trace;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_trace);

typedef struct {
	phys_bytes dst_addr;

	uint8_t padding[52];
} mess_krn_lsys_sys_umap;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_umap);

typedef struct {
	int pcount;

	uint8_t padding[52];
} mess_krn_lsys_sys_vumap;
_ASSERT_MSG_SIZE(mess_krn_lsys_sys_vumap);

typedef struct {
	off_t pos;

	int minor;
	int id;
	int access;

	int count;
	cp_grant_id_t grant;
	int flags;

	endpoint_t user;
	unsigned long request;

	uint8_t padding[16];
} mess_lbdev_lblockdriver_msg;
_ASSERT_MSG_SIZE(mess_lbdev_lblockdriver_msg);

typedef struct {
	int status;
	int id;

	uint8_t padding[48];
} mess_lblockdriver_lbdev_reply;
_ASSERT_MSG_SIZE(mess_lblockdriver_lbdev_reply);

typedef struct {
	int		id;
	int		num;
	int		cmd;
	int		opt;
	int		ret;
	uint8_t		padding[36];
} mess_lc_ipc_semctl;
_ASSERT_MSG_SIZE(mess_lc_ipc_semctl);

typedef struct {
	key_t		key;
	int		nr;
	int		flag;
	int		retid;
	uint8_t		padding[40];
} mess_lc_ipc_semget;
_ASSERT_MSG_SIZE(mess_lc_ipc_semget);

typedef struct {
	int		id;
	void		*ops;
	unsigned int	size;
	uint8_t		padding[42];
} mess_lc_ipc_semop;
_ASSERT_MSG_SIZE(mess_lc_ipc_semop);

typedef struct {
	int		id;
	const void	*addr;
	int		flag;
	void		*retaddr;
	uint8_t		padding[40];
} mess_lc_ipc_shmat;
_ASSERT_MSG_SIZE(mess_lc_ipc_shmat);

typedef struct {
	int		id;
	int		cmd;
	void		*buf;
	int		ret;
	uint8_t		padding[40];
} mess_lc_ipc_shmctl;
_ASSERT_MSG_SIZE(mess_lc_ipc_shmctl);

typedef struct {
	const void	*addr;
	uint8_t		padding[52];
} mess_lc_ipc_shmdt;
_ASSERT_MSG_SIZE(mess_lc_ipc_shmdt);

typedef struct {
	key_t		key;
	size_t		size;
	int		flag;
	int		retid;
	uint8_t		padding[40];
} mess_lc_ipc_shmget;
_ASSERT_MSG_SIZE(mess_lc_ipc_shmget);

typedef struct {
	vir_bytes name;
	size_t namelen;
	vir_bytes frame;
	size_t framelen;
	vir_bytes ps_str;

	uint8_t padding[36];
} mess_lc_pm_exec;
_ASSERT_MSG_SIZE(mess_lc_pm_exec);

typedef struct {
	int status;

	uint8_t padding[52];
} mess_lc_pm_exit;
_ASSERT_MSG_SIZE(mess_lc_pm_exit);

typedef struct {
	pid_t pid;

	uint8_t padding[52];
} mess_lc_pm_getsid;
_ASSERT_MSG_SIZE(mess_lc_pm_getsid);

typedef struct {
	int num;
	vir_bytes ptr;		/* gid_t * */

	uint8_t padding[48];
} mess_lc_pm_groups;
_ASSERT_MSG_SIZE(mess_lc_pm_groups);

typedef struct {
	int which;
	vir_bytes value;	/* const struct itimerval * */
	vir_bytes ovalue;	/* struct itimerval * */

	uint8_t padding[44];
} mess_lc_pm_itimer;
_ASSERT_MSG_SIZE(mess_lc_pm_itimer);

typedef struct {
	vir_bytes ctx;		/* mcontext_t * */

	uint8_t padding[52];
} mess_lc_pm_mcontext;
_ASSERT_MSG_SIZE(mess_lc_pm_mcontext);

typedef struct {
	int which;
	int who;
	int prio;

	uint8_t padding[44];
} mess_lc_pm_priority;
_ASSERT_MSG_SIZE(mess_lc_pm_priority);

typedef struct {
	pid_t pid;
	int req;
	vir_bytes addr;
	long data;

	uint8_t padding[40];
} mess_lc_pm_ptrace;
_ASSERT_MSG_SIZE(mess_lc_pm_ptrace);

typedef struct {
	int how;

	uint8_t padding[52];
} mess_lc_pm_reboot;
_ASSERT_MSG_SIZE(mess_lc_pm_reboot);

typedef struct {
	endpoint_t who;
	vir_bytes addr;

	uint8_t padding[48];
} mess_lc_pm_rusage;
_ASSERT_MSG_SIZE(mess_lc_pm_rusage);

typedef struct {
	gid_t gid;

	uint8_t padding[52];
} mess_lc_pm_setgid;
_ASSERT_MSG_SIZE(mess_lc_pm_setgid);

typedef struct {
	uid_t uid;

	uint8_t padding[52];
} mess_lc_pm_setuid;
_ASSERT_MSG_SIZE(mess_lc_pm_setuid);

typedef struct {
	pid_t pid;
	int nr;
	vir_bytes act;		/* const struct sigaction * */
	vir_bytes oact;		/* struct sigaction * */
	vir_bytes ret;		/* int (*)(void) */

	uint8_t padding[36];
} mess_lc_pm_sig;
_ASSERT_MSG_SIZE(mess_lc_pm_sig);

typedef struct {
	int how;
	vir_bytes ctx;
	sigset_t set;

	uint8_t padding[32];
} mess_lc_pm_sigset;
_ASSERT_MSG_SIZE(mess_lc_pm_sigset);

typedef struct {
	int action;
	int freq;
	int intr_type;
	vir_bytes ctl_ptr;
	vir_bytes mem_ptr;
	size_t mem_size;

	uint8_t padding[32];
} mess_lc_pm_sprof;
_ASSERT_MSG_SIZE(mess_lc_pm_sprof);

typedef struct {
	int req;
	int field;
	size_t len;
	vir_bytes value;

	uint8_t padding[40];
} mess_lc_pm_sysuname;
_ASSERT_MSG_SIZE(mess_lc_pm_sysuname);

typedef struct {
	time_t sec;

	clockid_t clk_id;
	int now;
	long nsec;

	uint8_t padding[36];
} mess_lc_pm_time;
_ASSERT_MSG_SIZE(mess_lc_pm_time);

typedef struct {
	pid_t pid;
	int options;
	vir_bytes addr;			/* struct rusage * */

	uint8_t padding[44];
} mess_lc_pm_wait4;
_ASSERT_MSG_SIZE(mess_lc_pm_wait4);

typedef struct {
	cp_grant_id_t grant;
	vir_bytes tm;			/* struct tm * */
	int flags;

	uint8_t padding[44];
} mess_lc_readclock_rtcdev;
_ASSERT_MSG_SIZE(mess_lc_readclock_rtcdev);

typedef struct {
	unsigned long request;
	vir_bytes arg;

	uint8_t padding[48];
} mess_lc_svrctl;
_ASSERT_MSG_SIZE(mess_lc_svrctl);

typedef struct {
	vir_bytes name;
	size_t len;
	int fd;
	uid_t owner;
	gid_t group;

	uint8_t padding[36];
} mess_lc_vfs_chown;
_ASSERT_MSG_SIZE(mess_lc_vfs_chown);

typedef struct {
	int fd;

	uint8_t padding[52];
} mess_lc_vfs_close;
_ASSERT_MSG_SIZE(mess_lc_vfs_close);

typedef struct {
	vir_bytes name;
	size_t len;
	int flags;
	mode_t mode;

	uint8_t padding[40];
} mess_lc_vfs_creat;
_ASSERT_MSG_SIZE(mess_lc_vfs_creat);

typedef struct {
	int fd;

	uint8_t padding[52];
} mess_lc_vfs_fchdir;
_ASSERT_MSG_SIZE(mess_lc_vfs_fchdir);

typedef struct {
	int fd;
	mode_t mode;

	uint8_t padding[48];
} mess_lc_vfs_fchmod;
_ASSERT_MSG_SIZE(mess_lc_vfs_fchmod);

typedef struct {
	int fd;
	int cmd;
	int arg_int;
	vir_bytes arg_ptr;	/* struct flock * */

	uint8_t padding[40];
} mess_lc_vfs_fcntl;
_ASSERT_MSG_SIZE(mess_lc_vfs_fcntl);

typedef struct {
	int fd;
	vir_bytes buf;		/* struct stat * */

	uint8_t padding[48];
} mess_lc_vfs_fstat;
_ASSERT_MSG_SIZE(mess_lc_vfs_fstat);

typedef struct {
	int fd;

	uint8_t padding[52];
} mess_lc_vfs_fsync;
_ASSERT_MSG_SIZE(mess_lc_vfs_fsync);

typedef struct {
	cp_grant_id_t grant;
	int pid;
	vir_bytes buff_p;
	size_t buff_sz;

	uint8_t padding[40];
} mess_lc_vfs_gcov;
_ASSERT_MSG_SIZE(mess_lc_vfs_gcov);

typedef struct {
	int32_t flags;
	size_t len;
	vir_bytes buf;		/* struct statvfs */

	uint8_t padding[44];
} mess_lc_vfs_getvfsstat;
_ASSERT_MSG_SIZE(mess_lc_vfs_getvfsstat);

typedef struct {
	int fd;
	unsigned long req;
	vir_bytes arg;

	uint8_t padding[44];
} mess_lc_vfs_ioctl;
_ASSERT_MSG_SIZE(mess_lc_vfs_ioctl);

typedef struct {
	vir_bytes name1;
	vir_bytes name2;
	size_t len1;
	size_t len2;

	uint8_t padding[40];
} mess_lc_vfs_link;
_ASSERT_MSG_SIZE(mess_lc_vfs_link);

typedef struct {
	off_t offset;

	int fd;
	int whence;

	uint8_t padding[40];
} mess_lc_vfs_lseek;
_ASSERT_MSG_SIZE(mess_lc_vfs_lseek);

typedef struct {
	dev_t device;

	vir_bytes name;
	size_t len;
	mode_t mode;

	uint8_t padding[36];
} mess_lc_vfs_mknod;
_ASSERT_MSG_SIZE(mess_lc_vfs_mknod);

typedef struct {
	int flags;
	size_t devlen;
	size_t pathlen;
	size_t typelen;
	size_t labellen;
	vir_bytes dev;
	vir_bytes path;
	vir_bytes type;
	vir_bytes label;

	uint8_t padding[20];
} mess_lc_vfs_mount;
_ASSERT_MSG_SIZE(mess_lc_vfs_mount);

typedef struct {
	vir_bytes name;
	size_t len;
	int flags;
	mode_t mode;
	char buf[M_PATH_STRING_MAX];
} mess_lc_vfs_path;
_ASSERT_MSG_SIZE(mess_lc_vfs_path);

typedef struct {
	int fd0;
	int fd1;
	int flags;

	uint8_t padding[44];
} mess_lc_vfs_pipe2;
_ASSERT_MSG_SIZE(mess_lc_vfs_pipe2);

typedef struct {
	vir_bytes name;		/* const char * */
	size_t namelen;
	vir_bytes buf;
	size_t bufsize;

	uint8_t padding[40];
} mess_lc_vfs_readlink;
_ASSERT_MSG_SIZE(mess_lc_vfs_readlink);

typedef struct {
	int fd;
	vir_bytes buf;
	size_t len;

	uint8_t padding[44];
} mess_lc_vfs_readwrite;
_ASSERT_MSG_SIZE(mess_lc_vfs_readwrite);

typedef struct {
	uint32_t nfds;
	fd_set *readfds;
	fd_set *writefds;
	fd_set *errorfds;
	vir_bytes timeout;	/* user-provided 'struct timeval *' */

	uint8_t padding[36];
} mess_lc_vfs_select;
_ASSERT_MSG_SIZE(mess_lc_vfs_select);

typedef struct {
	size_t len;
	vir_bytes name;		/* const char * */
	vir_bytes buf;		/* struct stat * */

	uint8_t padding[44];
} mess_lc_vfs_stat;
_ASSERT_MSG_SIZE(mess_lc_vfs_stat);

typedef struct {
	int fd;
	int flags;
	size_t len;
	vir_bytes name;
	vir_bytes buf;

	uint8_t padding[36];
} mess_lc_vfs_statvfs1;
_ASSERT_MSG_SIZE(mess_lc_vfs_statvfs1);

typedef struct {
	off_t offset;

	int fd;
	vir_bytes name;
	size_t len;

	uint8_t padding[36];
} mess_lc_vfs_truncate;
_ASSERT_MSG_SIZE(mess_lc_vfs_truncate);

typedef struct {
	mode_t mask;

	uint8_t padding[52];
} mess_lc_vfs_umask;
_ASSERT_MSG_SIZE(mess_lc_vfs_umask);

typedef struct {
	vir_bytes name;
	size_t namelen;
	vir_bytes label;
	size_t labellen;

	uint8_t padding[40];
} mess_lc_vfs_umount;
_ASSERT_MSG_SIZE(mess_lc_vfs_umount);

typedef struct {
	void		*addr;
	uint8_t		padding[52];
} mess_lc_vm_brk;
_ASSERT_MSG_SIZE(mess_lc_vm_brk);

typedef struct {
	endpoint_t	endpt;
	void		*addr;
	void		*ret_addr;
	uint8_t		padding[44];
} mess_lc_vm_getphys;
_ASSERT_MSG_SIZE(mess_lc_vm_getphys);

typedef struct {
	endpoint_t	forwhom;
	void		*addr;
	uint8_t		padding[48];
} mess_lc_vm_shm_unmap;
_ASSERT_MSG_SIZE(mess_lc_vm_shm_unmap);

typedef struct {
	int status;
	uint32_t id;		/* should be cdev_id_t */

	uint8_t padding[48];
} mess_lchardriver_vfs_reply;
_ASSERT_MSG_SIZE(mess_lchardriver_vfs_reply);

typedef struct {
	int status;
	int32_t minor;

	uint8_t padding[48];
} mess_lchardriver_vfs_sel1;
_ASSERT_MSG_SIZE(mess_lchardriver_vfs_sel1);

typedef struct {
	int status;
	int32_t minor;

	uint8_t padding[48];
} mess_lchardriver_vfs_sel2;
_ASSERT_MSG_SIZE(mess_lchardriver_vfs_sel2);

typedef struct {
	endpoint_t endpt;
	vir_bytes ptr;		/* struct exec_info * */

	uint8_t padding[48];
} mess_lexec_pm_exec_new;
_ASSERT_MSG_SIZE(mess_lexec_pm_exec_new);

typedef struct {
	cp_grant_id_t grant;

	uint8_t padding[52];
} mess_li2cdriver_i2c_busc_i2c_exec;
_ASSERT_MSG_SIZE(mess_li2cdriver_i2c_busc_i2c_exec);

typedef struct {
	uint16_t addr; /* FIXME: strictly speaking this is an i2c_addr_t, but
			  to get it I would need to include
			  sys/dev/i2c/i2c_io.h, which I am not sure is a good
			  idea to have everywhere. */

	uint8_t padding[54];
} mess_li2cdriver_i2c_busc_i2c_reserve;
_ASSERT_MSG_SIZE(mess_li2cdriver_i2c_busc_i2c_reserve);

typedef struct {
	int id;
	int page;
	int code;
	int value;
	int flags;

	uint8_t padding[36];
} mess_linputdriver_input_event;
_ASSERT_MSG_SIZE(mess_linputdriver_input_event);

typedef struct {
        cp_grant_id_t gid;
	size_t size;
	int subtype;

        uint8_t padding[44];
} mess_lsys_fi_ctl;
_ASSERT_MSG_SIZE(mess_lsys_fi_ctl);

typedef struct {
        int status;

        uint8_t padding[52];
} mess_lsys_fi_reply;
_ASSERT_MSG_SIZE(mess_lsys_fi_reply);

typedef struct {
	int what;
	vir_bytes where;
	size_t size;

	uint8_t padding[44];
} mess_lsys_getsysinfo;
_ASSERT_MSG_SIZE(mess_lsys_getsysinfo);

typedef struct {
	size_t size;
	phys_bytes addr;
	vir_bytes buf;

	uint8_t padding[44];
} mess_lsys_krn_readbios;
_ASSERT_MSG_SIZE(mess_lsys_krn_readbios);

typedef struct {
	endpoint_t	from_to;
	cp_grant_id_t	gid;
	size_t		offset;
	void		*address;
	size_t		bytes;
	uint8_t padding[36];
} mess_lsys_kern_safecopy;
_ASSERT_MSG_SIZE(mess_lsys_kern_safecopy);

typedef struct {
	uint32_t flags;
	endpoint_t endpoint;
	int priority;
	int quantum;
	int cpu;

	uint8_t padding[36];
} mess_lsys_krn_schedctl;
_ASSERT_MSG_SIZE(mess_lsys_krn_schedctl);

typedef struct {
	endpoint_t endpoint;
	int quantum;
	int priority;
	int cpu;

	uint8_t padding[40];
} mess_lsys_krn_schedule;
_ASSERT_MSG_SIZE(mess_lsys_krn_schedule);

typedef struct {
	int how;

	uint8_t padding[52];
} mess_lsys_krn_sys_abort;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_abort);

typedef struct {
	endpoint_t endpt;

	uint8_t padding[52];
} mess_lsys_krn_sys_clear;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_clear);

typedef struct {
	endpoint_t src_endpt;
	vir_bytes src_addr;
	endpoint_t dst_endpt;
	vir_bytes dst_addr;
	phys_bytes nr_bytes;
	int flags;

	uint8_t padding[32];
} mess_lsys_krn_sys_copy;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_copy);

typedef struct {
	int request;
	int port;
	uint32_t value;

	uint8_t padding[44];
} mess_lsys_krn_sys_devio;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_devio);

typedef struct {
	int code;
	vir_bytes buf;
	int len;
	endpoint_t endpt;

	uint8_t padding[40];
} mess_lsys_krn_sys_diagctl;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_diagctl);

typedef struct {
	endpoint_t endpt;
	vir_bytes ip;
	vir_bytes stack;
	vir_bytes name;
	vir_bytes ps_str;

	uint8_t padding[36];
} mess_lsys_krn_sys_exec;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_exec);

typedef struct {
	endpoint_t endpt;
	endpoint_t slot;
	uint32_t flags;

	uint8_t padding[44];
} mess_lsys_krn_sys_fork;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_fork);

typedef struct {
	int request;
	endpoint_t endpt;
	vir_bytes val_ptr;
	int val_len;
	vir_bytes val_ptr2;
	int val_len2_e;

	uint8_t padding[32];
} mess_lsys_krn_sys_getinfo;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_getinfo);

typedef struct {
	endpoint_t endpt;
	vir_bytes ctx_ptr;

	uint8_t padding[48];
} mess_lsys_krn_sys_getmcontext;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_getmcontext);

typedef struct {
	endpoint_t endpt;

	uint8_t padding[52];
} mess_lsys_krn_sys_iopenable;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_iopenable);

typedef struct {
	int request;
	int vector;
	int policy;
	int hook_id;

	uint8_t padding[40];
} mess_lsys_krn_sys_irqctl;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_irqctl);

typedef struct {
	phys_bytes base;
	phys_bytes count;
	unsigned long pattern;
	endpoint_t process;

	uint8_t padding[40];
} mess_lsys_krn_sys_memset;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_memset);

typedef struct {
	int request;
	endpoint_t endpt;
	vir_bytes arg_ptr;
	phys_bytes phys_start;
	phys_bytes phys_len;

	uint8_t padding[36];
} mess_lsys_krn_sys_privctl;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_privctl);

typedef struct {
	int request;
	long int port;
	endpoint_t vec_endpt;
	phys_bytes vec_addr;
	vir_bytes vec_size;
	vir_bytes offset;

	uint8_t padding[32];
} mess_lsys_krn_sys_sdevio;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_sdevio);

typedef struct {
	clock_t exp_time;
	clock_t time_left;
	clock_t uptime;
	int abs_time;

	uint8_t padding[40];
} mess_lsys_krn_sys_setalarm;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_setalarm);

typedef struct {
	vir_bytes addr;			/* cp_grant_t * */
	int size;

	uint8_t padding[48];
} mess_lsys_krn_sys_setgrant;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_setgrant);

typedef struct {
	endpoint_t endpt;
	vir_bytes ctx_ptr;

	uint8_t padding[48];
} mess_lsys_krn_sys_setmcontext;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_setmcontext);

typedef struct {
	time_t sec;		/* time in seconds since 1970 */
	long int nsec;
	int now;		/* non-zero for immediate, 0 for adjtime */
	clockid_t clock_id;

	uint8_t padding[36];
} mess_lsys_krn_sys_settime;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_settime);

typedef struct {
	int action;
	int freq;
	int intr_type;
	endpoint_t endpt;
	vir_bytes ctl_ptr;
	vir_bytes mem_ptr;
	size_t mem_size;

	uint8_t padding[28];
} mess_lsys_krn_sys_sprof;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_sprof);

typedef struct {
	int request;
	void *address;
	int length;

	uint8_t padding[44];
} mess_lsys_krn_sys_statectl;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_statectl);

typedef struct {
	time_t boot_time;

	uint8_t padding[48];
} mess_lsys_krn_sys_stime;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_stime);

typedef struct {
	endpoint_t endpt;

	uint8_t padding[52];
} mess_lsys_krn_sys_times;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_times);

typedef struct {
	int request;
	endpoint_t endpt;
	vir_bytes address;
	long int data;

	uint8_t padding[40];
} mess_lsys_krn_sys_trace;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_trace);

typedef struct {
	endpoint_t src_endpt;
	int segment;
	vir_bytes src_addr;
	endpoint_t dst_endpt;
	int nr_bytes;

	uint8_t padding[36];
} mess_lsys_krn_sys_umap;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_umap);


typedef struct {
	int request;
	int vec_size;
	vir_bytes vec_addr;		/* pv{b,w,l}_pair_t * */

	uint8_t padding[44];
} mess_lsys_krn_sys_vdevio;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_vdevio);

typedef struct {
	endpoint_t endpt;
	vir_bytes vaddr;			/* struct vumap_vir * */
	int vcount;
	vir_bytes paddr;			/* struct vumap_phys * */
	int pmax;
	int access;
	size_t offset;

	uint8_t padding[28];
} mess_lsys_krn_sys_vumap;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_vumap);

typedef struct {
	char name[32];
	int oflag;

	uint8_t padding[20];
} mess_lsys_krn_sys_mqueue_open;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_mqueue_open);

typedef struct {
	int mqdes;

	uint8_t padding[52];
} mess_lsys_krn_sys_mqueue_close;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_mqueue_close);

typedef struct {
	int mqdes;
	char msg[32];
	unsigned int msg_prio;
	endpoint_t dst[4];
} mess_lsys_krn_sys_mqueue_send;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_mqueue_send);

typedef struct {
	int mqdes;
	char msg[32];
	unsigned int msg_prio;
	endpoint_t dst;

	uint8_t padding[12];
} mess_lsys_krn_sys_mqueue_receive;
_ASSERT_MSG_SIZE(mess_lsys_krn_sys_mqueue_receive);

typedef struct {
	void		*vec_addr;
	int		vec_size;
	uint8_t padding[48];
} mess_lsys_kern_vsafecopy;
_ASSERT_MSG_SIZE(mess_lsys_kern_vsafecopy);

typedef struct {
	int devind;
	int port;

	uint8_t padding[48];
} mess_lsys_pci_busc_get_bar;
_ASSERT_MSG_SIZE(mess_lsys_pci_busc_get_bar);

typedef struct {
	endpoint_t endpt;

	uint8_t padding[52];
} mess_lsys_pm_getepinfo;
_ASSERT_MSG_SIZE(mess_lsys_pm_getepinfo);

typedef struct {
	pid_t pid;

	uint8_t padding[52];
} mess_lsys_pm_getprocnr;
_ASSERT_MSG_SIZE(mess_lsys_pm_getprocnr);

typedef struct {
	uid_t uid;
	gid_t gid;

	uint8_t padding[48];
} mess_lsys_pm_srv_fork;
_ASSERT_MSG_SIZE(mess_lsys_pm_srv_fork);

typedef struct {
	endpoint_t endpoint;
	endpoint_t parent;
	int maxprio;
	int quantum;

	uint8_t padding[40];
} mess_lsys_sched_scheduling_start;
_ASSERT_MSG_SIZE(mess_lsys_sched_scheduling_start);

typedef struct {
	endpoint_t endpoint;

	uint8_t padding[52];
} mess_lsys_sched_scheduling_stop;
_ASSERT_MSG_SIZE(mess_lsys_sched_scheduling_stop);

typedef struct {
	int request;
	int fkeys;
	int sfkeys;

	uint8_t padding[44];
} mess_lsys_tty_fkey_ctl;
_ASSERT_MSG_SIZE(mess_lsys_tty_fkey_ctl);

typedef struct {
	endpoint_t endpt;
	cp_grant_id_t grant;
	size_t count;

	uint8_t padding[44];
} mess_lsys_vfs_checkperms;
_ASSERT_MSG_SIZE(mess_lsys_vfs_checkperms);

typedef struct {
	endpoint_t endpt;
	int fd;
	int what;

	uint8_t padding[44];
} mess_lsys_vfs_copyfd;
_ASSERT_MSG_SIZE(mess_lsys_vfs_copyfd);

typedef struct {
	devmajor_t major;
	size_t labellen;
	vir_bytes label;

	uint8_t padding[44];
} mess_lsys_vfs_mapdriver;
_ASSERT_MSG_SIZE(mess_lsys_vfs_mapdriver);

typedef struct {
	endpoint_t	endpt;
	void		*addr;
	int		retc;
	uint8_t		padding[44];
} mess_lsys_vm_getref;
_ASSERT_MSG_SIZE(mess_lsys_vm_getref);

typedef struct {
	int		what;
	endpoint_t	ep;
	int		count;
	void		*ptr;
	vir_bytes	next;
	uint8_t		padding[36];
} mess_lsys_vm_info;
_ASSERT_MSG_SIZE(mess_lsys_vm_info);

typedef struct {
	endpoint_t	ep;
	phys_bytes	phaddr;
	size_t		len;
	void		*reply;
	uint8_t		padding[40];
} mess_lsys_vm_map_phys;
_ASSERT_MSG_SIZE(mess_lsys_vm_map_phys);

typedef struct {
	endpoint_t	ret_pt;
	int		is_more;
	uint8_t		padding[48];
} mess_lsys_vm_query_exit;
_ASSERT_MSG_SIZE(mess_lsys_vm_query_exit);

typedef struct {
	endpoint_t	endpt;
	vir_bytes	addr;
	int		children;

	uint8_t		padding[44];
} mess_lsys_vm_rusage;
_ASSERT_MSG_SIZE(mess_lsys_vm_rusage);

typedef struct {
	endpoint_t	ep;
	void		*vaddr;
	uint8_t		padding[48];
} mess_lsys_vm_unmap_phys;
_ASSERT_MSG_SIZE(mess_lsys_vm_unmap_phys);

typedef struct {
	endpoint_t src;
	endpoint_t dst;
	int flags;
	uint8_t		padding[44];
} mess_lsys_vm_update;
_ASSERT_MSG_SIZE(mess_lsys_vm_update);

typedef struct {
	endpoint_t	destination;
	endpoint_t	source;
	void		*dest_addr;
	void		*src_addr;
	size_t		size;
	void		*ret_addr;
	uint8_t		padding[32];
} mess_lsys_vm_vmremap;
_ASSERT_MSG_SIZE(mess_lsys_vm_vmremap);

typedef struct {
	endpoint_t	ep;
	uint8_t		padding[52];
} mess_lsys_vm_watch_exit;
_ASSERT_MSG_SIZE(mess_lsys_vm_watch_exit);

typedef struct {
	off_t offset;
	void *addr;
	size_t len;
	int prot;
	int flags;
	int fd;
	endpoint_t forwhom;
	void *retaddr;
	u32_t padding[5];
} mess_mmap;
_ASSERT_MSG_SIZE(mess_mmap);

typedef struct {
	int mode;

	uint8_t padding[52];
} mess_net_netdrv_dl_conf;
_ASSERT_MSG_SIZE(mess_net_netdrv_dl_conf);

typedef struct {
	cp_grant_id_t grant;

	uint8_t padding[52];
} mess_net_netdrv_dl_getstat_s;
_ASSERT_MSG_SIZE(mess_net_netdrv_dl_getstat_s);

typedef struct {
	cp_grant_id_t grant;
	int count;

	uint8_t padding[48];
} mess_net_netdrv_dl_readv_s;
_ASSERT_MSG_SIZE(mess_net_netdrv_dl_readv_s);

typedef struct {
	cp_grant_id_t grant;
	int count;

	uint8_t padding[48];
} mess_net_netdrv_dl_writev_s;
_ASSERT_MSG_SIZE(mess_net_netdrv_dl_writev_s);

typedef struct {
	int stat;
	uint8_t hw_addr[6];

	uint8_t padding[46];
} mess_netdrv_net_dl_conf;
_ASSERT_MSG_SIZE(mess_netdrv_net_dl_conf);

typedef struct {
	int count;
	uint32_t flags;

	uint8_t padding[48];
} mess_netdrv_net_dl_task;
_ASSERT_MSG_SIZE(mess_netdrv_net_dl_task);

typedef struct {
	u64_t timestamp;	/* valid for every notify msg */
	u64_t interrupts;	/* raised interrupts; valid if from HARDWARE */
	sigset_t sigset;	/* raised signals; valid if from SYSTEM */
	uint8_t padding[24];
} mess_notify;
_ASSERT_MSG_SIZE(mess_notify);

typedef struct {
	int base;
	size_t size;
	uint32_t flags;

	uint8_t padding[44];
} mess_pci_lsys_busc_get_bar;
_ASSERT_MSG_SIZE(mess_pci_lsys_busc_get_bar);

typedef struct {
	uid_t egid;

	uint8_t padding[52];
} mess_pm_lc_getgid;
_ASSERT_MSG_SIZE(mess_pm_lc_getgid);

typedef struct {
	pid_t parent_pid;

	uint8_t padding[52];
} mess_pm_lc_getpid;
_ASSERT_MSG_SIZE(mess_pm_lc_getpid);

typedef struct {
	uid_t euid;

	uint8_t padding[52];
} mess_pm_lc_getuid;
_ASSERT_MSG_SIZE(mess_pm_lc_getuid);

typedef struct {
	long data;

	uint8_t padding[52];
} mess_pm_lc_ptrace;
_ASSERT_MSG_SIZE(mess_pm_lc_ptrace);

typedef struct {
	sigset_t set;

	uint8_t padding[40];
} mess_pm_lc_sigset;
_ASSERT_MSG_SIZE(mess_pm_lc_sigset);

typedef struct {
	time_t sec;

	long nsec;

	uint8_t padding[44];
} mess_pm_lc_time;
_ASSERT_MSG_SIZE(mess_pm_lc_time);

typedef struct {
	int status;

	uint8_t padding[52];
} mess_pm_lc_wait4;
_ASSERT_MSG_SIZE(mess_pm_lc_wait4);

typedef struct {
	int suid;

	uint8_t padding[52];
} mess_pm_lexec_exec_new;
_ASSERT_MSG_SIZE(mess_pm_lexec_exec_new);

typedef struct {
	uid_t uid;
	gid_t gid;

	uint8_t padding[48];
} mess_pm_lsys_getepinfo;
_ASSERT_MSG_SIZE(mess_pm_lsys_getepinfo);

typedef struct {
	endpoint_t endpt;

	uint8_t padding[52];
} mess_pm_lsys_getprocnr;
_ASSERT_MSG_SIZE(mess_pm_lsys_getprocnr);

typedef struct {
	int num;

	uint8_t padding[52];
} mess_pm_lsys_sigs_signal;
_ASSERT_MSG_SIZE(mess_pm_lsys_sigs_signal);

typedef struct {
	endpoint_t endpoint;
	uint32_t maxprio;

	uint8_t padding[48];
} mess_pm_sched_scheduling_set_nice;
_ASSERT_MSG_SIZE(mess_pm_sched_scheduling_set_nice);

typedef struct {
	dev_t dev;
	mode_t mode;
	uid_t uid;
	gid_t gid;
	uint32_t index;

	uint8_t padding[32];
} mess_pty_ptyfs_req;
_ASSERT_MSG_SIZE(mess_pty_ptyfs_req);

typedef struct {
	char name[20];

	uint8_t padding[36];
} mess_ptyfs_pty_name;
_ASSERT_MSG_SIZE(mess_ptyfs_pty_name);

typedef struct {
	int status;

	uint8_t padding[52];
} mess_readclock_lc_rtcdev;
_ASSERT_MSG_SIZE(mess_readclock_lc_rtcdev);

typedef struct {
	int		result;
	int		type;
	cp_grant_id_t	rproctab_gid;
	endpoint_t	old_endpoint;
	int		restarts;
	int		flags;
	vir_bytes	buff_addr;
	size_t		buff_len;
	int		prepare_state;
	uint8_t padding[20];
} mess_rs_init;
_ASSERT_MSG_SIZE(mess_rs_init);

typedef struct {
	endpoint_t endpt;
	int result;
	vir_bytes pc;
	vir_bytes ps_str;

	uint8_t padding[40];
} mess_rs_pm_exec_restart;
_ASSERT_MSG_SIZE(mess_rs_pm_exec_restart);

typedef struct {
	pid_t pid;
	int nr;

	uint8_t padding[48];
} mess_rs_pm_srv_kill;
_ASSERT_MSG_SIZE(mess_rs_pm_srv_kill);

typedef struct {
	int		len;
	int		name_len;
	endpoint_t	endpoint;
	void		*addr;
	const char	*name;
	int		subtype;
	uint8_t padding[32];
} mess_rs_req;
_ASSERT_MSG_SIZE(mess_rs_req);

typedef struct {
	int		result;
	int		state;
	int		prepare_maxtime;
	int		flags;
	gid_t		state_data_gid;
	uint8_t padding[36];
} mess_rs_update;
_ASSERT_MSG_SIZE(mess_rs_update);

typedef struct {
	endpoint_t scheduler;

	uint8_t padding[52];
} mess_sched_lsys_scheduling_start;
_ASSERT_MSG_SIZE(mess_sched_lsys_scheduling_start);

/* For SYS_GETKSIG, _ENDKSIG, _KILL, _SIGSEND, _SIGRETURN. */
typedef struct {
	sigset_t map;		/* used to pass signal bit map */
	endpoint_t endpt;	/* process number for inform */
	int sig;		/* signal number to send */
	void *sigctx;		/* pointer to signal context */
	uint8_t padding[28];
} mess_sigcalls;
_ASSERT_MSG_SIZE(mess_sigcalls);

typedef struct {
	int fkeys;
	int sfkeys;

	uint8_t padding[48];
} mess_tty_lsys_fkey_ctl;
_ASSERT_MSG_SIZE(mess_tty_lsys_fkey_ctl);

typedef struct {
	dev_t device;
	off_t seek_pos;

	cp_grant_id_t grant;
	size_t nbytes;

	uint8_t data[32];
} mess_vfs_fs_breadwrite;
_ASSERT_MSG_SIZE(mess_vfs_fs_breadwrite);

typedef struct {
	ino_t inode;

	mode_t mode;

	uint8_t data[44];
} mess_vfs_fs_chmod;
_ASSERT_MSG_SIZE(mess_vfs_fs_chmod);

typedef struct {
	ino_t inode;

	uid_t uid;
	gid_t gid;

	uint8_t data[40];
} mess_vfs_fs_chown;
_ASSERT_MSG_SIZE(mess_vfs_fs_chown);

typedef struct {
	ino_t inode;

	mode_t mode;
	uid_t uid;
	gid_t gid;
	cp_grant_id_t grant;
	size_t path_len;

	uint8_t data[28];
} mess_vfs_fs_create;
_ASSERT_MSG_SIZE(mess_vfs_fs_create);

typedef struct {
	dev_t device;

	uint8_t data[48];
} mess_vfs_fs_flush;
_ASSERT_MSG_SIZE(mess_vfs_fs_flush);

typedef struct {
	ino_t inode;
	off_t trc_start;
	off_t trc_end;

	uint8_t data[32];
} mess_vfs_fs_ftrunc;
_ASSERT_MSG_SIZE(mess_vfs_fs_ftrunc);

typedef struct {
	ino_t inode;
	off_t seek_pos;

	cp_grant_id_t grant;
	size_t mem_size;

	uint8_t data[32];
} mess_vfs_fs_getdents;
_ASSERT_MSG_SIZE(mess_vfs_fs_getdents);

typedef struct {
	ino_t inode;

	uint8_t data[48];
} mess_vfs_fs_inhibread;
_ASSERT_MSG_SIZE(mess_vfs_fs_inhibread);

typedef struct {
	ino_t inode;
	ino_t dir_ino;

	cp_grant_id_t grant;
	size_t path_len;

	uint8_t data[32];
} mess_vfs_fs_link;
_ASSERT_MSG_SIZE(mess_vfs_fs_link);

typedef struct {
	ino_t dir_ino;
	ino_t root_ino;

	uint32_t flags;
	size_t path_len;
	size_t path_size;
	size_t ucred_size;
	cp_grant_id_t grant_path;
	cp_grant_id_t grant_ucred;
	uid_t uid;
	gid_t gid;

	uint8_t data[8];
} mess_vfs_fs_lookup;
_ASSERT_MSG_SIZE(mess_vfs_fs_lookup);

typedef struct {
	ino_t inode;

	mode_t mode;
	uid_t uid;
	gid_t gid;
	cp_grant_id_t grant;
	size_t path_len;

	uint8_t data[28];
} mess_vfs_fs_mkdir;
_ASSERT_MSG_SIZE(mess_vfs_fs_mkdir);

typedef struct {
	dev_t device;
	ino_t inode;

	mode_t mode;
	uid_t uid;
	gid_t gid;
	cp_grant_id_t grant;
	size_t path_len;

	uint8_t data[20];
} mess_vfs_fs_mknod;
_ASSERT_MSG_SIZE(mess_vfs_fs_mknod);

typedef struct {
	ino_t inode;

	uint8_t data[48];
} mess_vfs_fs_mountpoint;
_ASSERT_MSG_SIZE(mess_vfs_fs_mountpoint);

typedef struct {
	dev_t device;

	cp_grant_id_t grant;
	size_t path_len;

	uint8_t data[40];
} mess_vfs_fs_new_driver;
_ASSERT_MSG_SIZE(mess_vfs_fs_new_driver);

typedef struct {
	dev_t device;

	mode_t mode;
	uid_t uid;
	gid_t gid;

	uint8_t data[36];
} mess_vfs_fs_newnode;
_ASSERT_MSG_SIZE(mess_vfs_fs_newnode);

typedef struct {
	ino_t inode;
	unsigned int count;

	uint8_t data[44];
} mess_vfs_fs_putnode;
_ASSERT_MSG_SIZE(mess_vfs_fs_putnode);

typedef struct {
	ino_t inode;

	cp_grant_id_t grant;
	size_t mem_size;

	uint8_t data[40];
} mess_vfs_fs_rdlink;
_ASSERT_MSG_SIZE(mess_vfs_fs_rdlink);

typedef struct {
	dev_t device;

	uint32_t flags;
	size_t path_len;
	cp_grant_id_t grant;

	uint8_t data[36];
} mess_vfs_fs_readsuper;
_ASSERT_MSG_SIZE(mess_vfs_fs_readsuper);

typedef struct {
	ino_t inode;
	off_t seek_pos;

	cp_grant_id_t grant;
	size_t nbytes;

	uint8_t data[32];
} mess_vfs_fs_readwrite;
_ASSERT_MSG_SIZE(mess_vfs_fs_readwrite);

typedef struct {
	ino_t dir_old;
	ino_t dir_new;

	size_t len_old;
	size_t len_new;
	cp_grant_id_t grant_old;
	cp_grant_id_t grant_new;

	uint8_t data[24];
} mess_vfs_fs_rename;
_ASSERT_MSG_SIZE(mess_vfs_fs_rename);

typedef struct {
	ino_t inode;

	size_t path_len;
	size_t mem_size;
	cp_grant_id_t grant_path;
	cp_grant_id_t grant_target;
	uid_t uid;
	gid_t gid;

	uint8_t data[24];
} mess_vfs_fs_slink;
_ASSERT_MSG_SIZE(mess_vfs_fs_slink);

typedef struct {
	ino_t inode;

	cp_grant_id_t grant;

	uint8_t data[44];
} mess_vfs_fs_stat;
_ASSERT_MSG_SIZE(mess_vfs_fs_stat);

typedef struct {
	cp_grant_id_t grant;

	uint8_t data[52];
} mess_vfs_fs_statvfs;
_ASSERT_MSG_SIZE(mess_vfs_fs_statvfs);

typedef struct {
	ino_t inode;

	cp_grant_id_t grant;
	size_t path_len;

	uint8_t data[40];
} mess_vfs_fs_unlink;
_ASSERT_MSG_SIZE(mess_vfs_fs_unlink);

typedef struct {
	ino_t inode;
	time_t actime;
	time_t modtime;

	uint32_t acnsec;
	uint32_t modnsec;

	uint8_t data[24];
} mess_vfs_fs_utime;
_ASSERT_MSG_SIZE(mess_vfs_fs_utime);

typedef struct {
	off_t offset;

	uint8_t padding[48];
} mess_vfs_lc_lseek;
_ASSERT_MSG_SIZE(mess_vfs_lc_lseek);

typedef struct {
	endpoint_t id;
	devminor_t minor;

	uint8_t padding[48];
} mess_vfs_lchardriver_cancel;
_ASSERT_MSG_SIZE(mess_vfs_lchardriver_cancel);

typedef struct {
	endpoint_t id;
	endpoint_t user;
	devminor_t minor;
	int access;

	uint8_t padding[40];
} mess_vfs_lchardriver_openclose;
_ASSERT_MSG_SIZE(mess_vfs_lchardriver_openclose);

typedef struct {
	off_t pos;
	cp_grant_id_t grant;
	size_t count;
	unsigned long request;
	int flags;
	endpoint_t id;
	endpoint_t user;
	devminor_t minor;

	uint8_t padding[20];
} mess_vfs_lchardriver_readwrite;
_ASSERT_MSG_SIZE(mess_vfs_lchardriver_readwrite);

typedef struct {
	devminor_t minor;
	int ops;

	uint8_t padding[48];
} mess_vfs_lchardriver_select;
_ASSERT_MSG_SIZE(mess_vfs_lchardriver_select);

typedef struct {
	time_t atime;
	time_t mtime;
	long ansec;
	long mnsec;
	size_t len;
	char *name;
	int fd;
	int flags;
	uint8_t padding[16];
} mess_vfs_utimens;
_ASSERT_MSG_SIZE(mess_vfs_utimens);

typedef struct {
	off_t offset;
	dev_t dev;
	ino_t ino;
	endpoint_t who;
	u32_t vaddr;
	u32_t len;
	u32_t flags;
	u32_t fd;
	u16_t clearend;
	uint8_t padding[8];
} mess_vm_vfs_mmap;
_ASSERT_MSG_SIZE(mess_vm_vfs_mmap);

typedef struct {
	dev_t dev;	/* 64bits long. */
	off_t dev_offset;
	off_t ino_offset;
	ino_t ino;
	void *block;
	u32_t *flags_ptr;
	u8_t pages;
	u8_t flags;
	uint8_t padding[12];
} mess_vmmcp;
_ASSERT_MSG_SIZE(mess_vmmcp);

typedef struct {
	void *addr;
	u8_t flags;
	uint8_t padding[51];
} mess_vmmcp_reply;
_ASSERT_MSG_SIZE(mess_vmmcp_reply);

typedef struct noxfer_message {
	endpoint_t m_source;		/* who sent the message */
	int m_type;			/* what kind of message is it */
	union {
		mess_u8			m_u8;
		mess_u16		m_u16;
		mess_u32		m_u32;
		mess_u64		m_u64;

		mess_1			m_m1;
		mess_2			m_m2;
		mess_3			m_m3;
		mess_4			m_m4;
		mess_7			m_m7;
		mess_9			m_m9;
		mess_10			m_m10;

		mess_ds_reply		m_ds_reply;
		mess_ds_req		m_ds_req;
		mess_fs_vfs_breadwrite	m_fs_vfs_breadwrite;
		mess_fs_vfs_chmod	m_fs_vfs_chmod;
		mess_fs_vfs_chown	m_fs_vfs_chown;
		mess_fs_vfs_create	m_fs_vfs_create;
		mess_fs_vfs_getdents	m_fs_vfs_getdents;
		mess_fs_vfs_lookup	m_fs_vfs_lookup;
		mess_fs_vfs_newnode	m_fs_vfs_newnode;
		mess_fs_vfs_rdlink	m_fs_vfs_rdlink;
		mess_fs_vfs_readsuper	m_fs_vfs_readsuper;
		mess_fs_vfs_readwrite	m_fs_vfs_readwrite;
		mess_i2c_li2cdriver_busc_i2c_exec m_i2c_li2cdriver_busc_i2c_exec;
		mess_i2c_li2cdriver_busc_i2c_reserve m_i2c_li2cdriver_busc_i2c_reserve;
		mess_input_linputdriver_input_conf m_input_linputdriver_input_conf;
		mess_input_linputdriver_setleds m_input_linputdriver_setleds;
		mess_input_tty_event	m_input_tty_event;
		mess_krn_lsys_schedule	m_krn_lsys_schedule;
		mess_krn_lsys_sys_devio m_krn_lsys_sys_devio;
		mess_krn_lsys_sys_fork m_krn_lsys_sys_fork;
		mess_krn_lsys_sys_getwhoami m_krn_lsys_sys_getwhoami;
		mess_krn_lsys_sys_irqctl m_krn_lsys_sys_irqctl;
		mess_krn_lsys_sys_times	m_krn_lsys_sys_times;
		mess_krn_lsys_sys_trace	m_krn_lsys_sys_trace;
		mess_krn_lsys_sys_umap	m_krn_lsys_sys_umap;
		mess_krn_lsys_sys_vumap	m_krn_lsys_sys_vumap;
		mess_lbdev_lblockdriver_msg m_lbdev_lblockdriver_msg;
		mess_lblockdriver_lbdev_reply m_lblockdriver_lbdev_reply;
		mess_lc_ipc_semctl	m_lc_ipc_semctl;
		mess_lc_ipc_semget	m_lc_ipc_semget;
		mess_lc_ipc_semop	m_lc_ipc_semop;
		mess_lc_ipc_shmat	m_lc_ipc_shmat;
		mess_lc_ipc_shmctl	m_lc_ipc_shmctl;
		mess_lc_ipc_shmdt	m_lc_ipc_shmdt;
		mess_lc_ipc_shmget	m_lc_ipc_shmget;
		mess_lc_pm_exec		m_lc_pm_exec;
		mess_lc_pm_exit		m_lc_pm_exit;
		mess_lc_pm_getsid	m_lc_pm_getsid;
		mess_lc_pm_groups	m_lc_pm_groups;
		mess_lc_pm_itimer	m_lc_pm_itimer;
		mess_lc_pm_mcontext	m_lc_pm_mcontext;
		mess_lc_pm_priority	m_lc_pm_priority;
		mess_lc_pm_ptrace	m_lc_pm_ptrace;
		mess_lc_pm_reboot	m_lc_pm_reboot;
		mess_lc_pm_rusage	m_lc_pm_rusage;
		mess_lc_pm_setgid	m_lc_pm_setgid;
		mess_lc_pm_setuid	m_lc_pm_setuid;
		mess_lc_pm_sig		m_lc_pm_sig;
		mess_lc_pm_sigset	m_lc_pm_sigset;
		mess_lc_pm_sprof	m_lc_pm_sprof;
		mess_lc_pm_sysuname	m_lc_pm_sysuname;
		mess_lc_pm_time		m_lc_pm_time;
		mess_lc_pm_wait4	m_lc_pm_wait4;
		mess_lc_readclock_rtcdev m_lc_readclock_rtcdev;
		mess_lc_svrctl		m_lc_svrctl;
		mess_lc_vfs_chown	m_lc_vfs_chown;
		mess_lc_vfs_close	m_lc_vfs_close;
		mess_lc_vfs_creat	m_lc_vfs_creat;
		mess_lc_vfs_fchdir	m_lc_vfs_fchdir;
		mess_lc_vfs_fchmod	m_lc_vfs_fchmod;
		mess_lc_vfs_fcntl	m_lc_vfs_fcntl;
		mess_lc_vfs_fstat	m_lc_vfs_fstat;
		mess_lc_vfs_fsync	m_lc_vfs_fsync;
		mess_lc_vfs_gcov	m_lc_vfs_gcov;
		mess_lc_vfs_getvfsstat	m_lc_vfs_getvfsstat;
		mess_lc_vfs_ioctl	m_lc_vfs_ioctl;
		mess_lc_vfs_link	m_lc_vfs_link;
		mess_lc_vfs_lseek	m_lc_vfs_lseek;
		mess_lc_vfs_mknod	m_lc_vfs_mknod;
		mess_lc_vfs_mount	m_lc_vfs_mount;
		mess_lc_vfs_path	m_lc_vfs_path;
		mess_lc_vfs_pipe2	m_lc_vfs_pipe2;
		mess_lc_vfs_readlink	m_lc_vfs_readlink;
		mess_lc_vfs_readwrite	m_lc_vfs_readwrite;
		mess_lc_vfs_select	m_lc_vfs_select;
		mess_lc_vfs_stat	m_lc_vfs_stat;
		mess_lc_vfs_statvfs1	m_lc_vfs_statvfs1;
		mess_lc_vfs_truncate	m_lc_vfs_truncate;
		mess_lc_vfs_umask	m_lc_vfs_umask;
		mess_lc_vfs_umount	m_lc_vfs_umount;
		mess_lc_vm_brk		m_lc_vm_brk;
		mess_lc_vm_getphys	m_lc_vm_getphys;
		mess_lc_vm_shm_unmap	m_lc_vm_shm_unmap;
		mess_lchardriver_vfs_reply m_lchardriver_vfs_reply;
		mess_lchardriver_vfs_sel1 m_lchardriver_vfs_sel1;
		mess_lchardriver_vfs_sel2 m_lchardriver_vfs_sel2;
		mess_lexec_pm_exec_new	m_lexec_pm_exec_new;
		mess_li2cdriver_i2c_busc_i2c_exec m_li2cdriver_i2c_busc_i2c_exec;
		mess_li2cdriver_i2c_busc_i2c_reserve m_li2cdriver_i2c_busc_i2c_reserve;
		mess_linputdriver_input_event m_linputdriver_input_event;
		mess_lsys_fi_ctl	m_lsys_fi_ctl;
		mess_lsys_fi_reply	m_lsys_fi_reply;
		mess_lsys_getsysinfo	m_lsys_getsysinfo;
		mess_lsys_krn_readbios	m_lsys_krn_readbios;
		mess_lsys_kern_safecopy	m_lsys_kern_safecopy;
		mess_lsys_krn_schedctl	m_lsys_krn_schedctl;
		mess_lsys_krn_schedule	m_lsys_krn_schedule;
		mess_lsys_krn_sys_abort m_lsys_krn_sys_abort;
		mess_lsys_krn_sys_clear m_lsys_krn_sys_clear;
		mess_lsys_krn_sys_copy	m_lsys_krn_sys_copy;
		mess_lsys_krn_sys_devio m_lsys_krn_sys_devio;
		mess_lsys_krn_sys_diagctl m_lsys_krn_sys_diagctl;
		mess_lsys_krn_sys_exec	m_lsys_krn_sys_exec;
		mess_lsys_krn_sys_fork	m_lsys_krn_sys_fork;
		mess_lsys_krn_sys_getinfo m_lsys_krn_sys_getinfo;
		mess_lsys_krn_sys_getmcontext m_lsys_krn_sys_getmcontext;
		mess_lsys_krn_sys_iopenable m_lsys_krn_sys_iopenable;
		mess_lsys_krn_sys_irqctl m_lsys_krn_sys_irqctl;
		mess_lsys_krn_sys_memset m_lsys_krn_sys_memset;
		mess_lsys_krn_sys_privctl m_lsys_krn_sys_privctl;
		mess_lsys_krn_sys_sdevio m_lsys_krn_sys_sdevio;
		mess_lsys_krn_sys_setalarm m_lsys_krn_sys_setalarm;
		mess_lsys_krn_sys_setgrant m_lsys_krn_sys_setgrant;
		mess_lsys_krn_sys_setmcontext m_lsys_krn_sys_setmcontext;
		mess_lsys_krn_sys_settime m_lsys_krn_sys_settime;
		mess_lsys_krn_sys_sprof m_lsys_krn_sys_sprof;
		mess_lsys_krn_sys_statectl m_lsys_krn_sys_statectl;
		mess_lsys_krn_sys_stime	m_lsys_krn_sys_stime;
		mess_lsys_krn_sys_times	m_lsys_krn_sys_times;
		mess_lsys_krn_sys_trace	m_lsys_krn_sys_trace;
		mess_lsys_krn_sys_umap	m_lsys_krn_sys_umap;
		mess_lsys_krn_sys_vdevio m_lsys_krn_sys_vdevio;
		mess_lsys_krn_sys_vumap m_lsys_krn_sys_vumap;
		mess_lsys_kern_vsafecopy m_lsys_kern_vsafecopy;
		mess_lsys_pci_busc_get_bar m_lsys_pci_busc_get_bar;
		mess_lsys_pm_getepinfo	m_lsys_pm_getepinfo;
		mess_lsys_pm_getprocnr	m_lsys_pm_getprocnr;
		mess_lsys_pm_srv_fork	m_lsys_pm_srv_fork;
		mess_lsys_sched_scheduling_start m_lsys_sched_scheduling_start;
		mess_lsys_sched_scheduling_stop m_lsys_sched_scheduling_stop;
		mess_lsys_tty_fkey_ctl	m_lsys_tty_fkey_ctl;
		mess_lsys_vfs_checkperms m_lsys_vfs_checkperms;
		mess_lsys_vfs_copyfd	m_lsys_vfs_copyfd;
		mess_lsys_vfs_mapdriver	m_lsys_vfs_mapdriver;
		mess_lsys_vm_getref	m_lsys_vm_getref;
		mess_lsys_vm_info	m_lsys_vm_info;
		mess_lsys_vm_map_phys	m_lsys_vm_map_phys;
		mess_lsys_vm_query_exit	m_lsys_vm_query_exit;
		mess_lsys_vm_rusage	m_lsys_vm_rusage;
		mess_lsys_vm_unmap_phys	m_lsys_vm_unmap_phys;
		mess_lsys_vm_update	m_lsys_vm_update;
		mess_lsys_vm_vmremap	m_lsys_vm_vmremap;
		mess_lsys_vm_watch_exit	m_lsys_vm_watch_exit;
		mess_mmap		m_mmap;
		mess_net_netdrv_dl_conf m_net_netdrv_dl_conf;
		mess_net_netdrv_dl_getstat_s m_net_netdrv_dl_getstat_s;
		mess_net_netdrv_dl_readv_s m_net_netdrv_dl_readv_s;
		mess_net_netdrv_dl_writev_s m_net_netdrv_dl_writev_s;
		mess_netdrv_net_dl_conf m_netdrv_net_dl_conf;
		mess_netdrv_net_dl_task m_netdrv_net_dl_task;
		mess_notify		m_notify;
		mess_pci_lsys_busc_get_bar m_pci_lsys_busc_get_bar;
		mess_pm_lc_getgid	m_pm_lc_getgid;
		mess_pm_lc_getpid	m_pm_lc_getpid;
		mess_pm_lc_getuid	m_pm_lc_getuid;
		mess_pm_lc_ptrace	m_pm_lc_ptrace;
		mess_pm_lc_sigset	m_pm_lc_sigset;
		mess_pm_lc_time		m_pm_lc_time;
		mess_pm_lc_wait4	m_pm_lc_wait4;
		mess_pm_lexec_exec_new	m_pm_lexec_exec_new;
		mess_pm_lsys_getepinfo	m_pm_lsys_getepinfo;
		mess_pm_lsys_getprocnr	m_pm_lsys_getprocnr;
		mess_pm_lsys_sigs_signal m_pm_lsys_sigs_signal;
		mess_pm_sched_scheduling_set_nice m_pm_sched_scheduling_set_nice;
		mess_pty_ptyfs_req	m_pty_ptyfs_req;
		mess_ptyfs_pty_name	m_ptyfs_pty_name;
		mess_readclock_lc_rtcdev m_readclock_lc_rtcdev;
		mess_rs_init		m_rs_init;
		mess_rs_pm_exec_restart	m_rs_pm_exec_restart;
		mess_rs_pm_srv_kill	m_rs_pm_srv_kill;
		mess_rs_req		m_rs_req;
		mess_rs_update		m_rs_update;
		mess_sched_lsys_scheduling_start m_sched_lsys_scheduling_start;
		mess_sigcalls		m_sigcalls;
		mess_tty_lsys_fkey_ctl	m_tty_lsys_fkey_ctl;
		mess_vfs_fs_breadwrite	m_vfs_fs_breadwrite;
		mess_vfs_fs_chmod	m_vfs_fs_chmod;
		mess_vfs_fs_chown	m_vfs_fs_chown;
		mess_vfs_fs_create	m_vfs_fs_create;
		mess_vfs_fs_flush	m_vfs_fs_flush;
		mess_vfs_fs_ftrunc	m_vfs_fs_ftrunc;
		mess_vfs_fs_getdents	m_vfs_fs_getdents;
		mess_vfs_fs_inhibread	m_vfs_fs_inhibread;
		mess_vfs_fs_link	m_vfs_fs_link;
		mess_vfs_fs_lookup	m_vfs_fs_lookup;
		mess_vfs_fs_mkdir	m_vfs_fs_mkdir;
		mess_vfs_fs_mknod	m_vfs_fs_mknod;
		mess_vfs_fs_mountpoint	m_vfs_fs_mountpoint;
		mess_vfs_fs_new_driver	m_vfs_fs_new_driver;
		mess_vfs_fs_newnode	m_vfs_fs_newnode;
		mess_vfs_fs_putnode	m_vfs_fs_putnode;
		mess_vfs_fs_rdlink	m_vfs_fs_rdlink;
		mess_vfs_fs_readsuper	m_vfs_fs_readsuper;
		mess_vfs_fs_readwrite	m_vfs_fs_readwrite;
		mess_vfs_fs_rename	m_vfs_fs_rename;
		mess_vfs_fs_slink	m_vfs_fs_slink;
		mess_vfs_fs_stat	m_vfs_fs_stat;
		mess_vfs_fs_statvfs	m_vfs_fs_statvfs;
		mess_vfs_fs_unlink	m_vfs_fs_unlink;
		mess_vfs_fs_utime	m_vfs_fs_utime;
		mess_vfs_lc_lseek	m_vfs_lc_lseek;
		mess_vfs_lchardriver_cancel	m_vfs_lchardriver_cancel;
		mess_vfs_lchardriver_openclose	m_vfs_lchardriver_openclose;
		mess_vfs_lchardriver_readwrite	m_vfs_lchardriver_readwrite;
		mess_vfs_lchardriver_select	m_vfs_lchardriver_select;
		mess_vfs_utimens	m_vfs_utimens;
		mess_vm_vfs_mmap	m_vm_vfs_mmap;
		mess_vmmcp		m_vmmcp;
		mess_vmmcp_reply	m_vmmcp_reply;
		mess_lsys_krn_sys_mqueue_open m_lsys_krn_sys_mqueue_open;
		mess_lsys_krn_sys_mqueue_close m_lsys_krn_sys_mqueue_close;
		mess_lsys_krn_sys_mqueue_send m_lsys_krn_sys_mqueue_send;
		mess_lsys_krn_sys_mqueue_receive m_lsys_krn_sys_mqueue_receive;

		u8_t size[56];	/* message payload may have 56 bytes at most */
	};
} message __ALIGNED(16);

/* Ensure the complete union respects the IPC assumptions. */
typedef int _ASSERT_message[/* CONSTCOND */sizeof(message) == 64 ? 1 : -1];

/* The following defines provide names for useful members. */
#define m1_i1  m_m1.m1i1
#define m1_i2  m_m1.m1i2
#define m1_i3  m_m1.m1i3
#define m1_p1  m_m1.m1p1
#define m1_p2  m_m1.m1p2
#define m1_p3  m_m1.m1p3
#define m1_p4  m_m1.m1p4
#define m1_ull1  m_m1.m1ull1

#define m2_ll1  m_m2.m2ll1
#define m2_i1  m_m2.m2i1
#define m2_i2  m_m2.m2i2
#define m2_i3  m_m2.m2i3
#define m2_l1  m_m2.m2l1
#define m2_l2  m_m2.m2l2
#define m2_p1  m_m2.m2p1
#define m2_sigset  m_m2.sigset

#define m2_s1  m_m2.m2s1

#define m3_i1  m_m3.m3i1
#define m3_i2  m_m3.m3i2
#define m3_p1  m_m3.m3p1
#define m3_ca1 m_m3.m3ca1

#define m4_ll1  m_m4.m4ll1
#define m4_l1  m_m4.m4l1
#define m4_l2  m_m4.m4l2
#define m4_l3  m_m4.m4l3
#define m4_l4  m_m4.m4l4
#define m4_l5  m_m4.m4l5

#define m7_i1  m_m7.m7i1
#define m7_i2  m_m7.m7i2
#define m7_i3  m_m7.m7i3
#define m7_i4  m_m7.m7i4
#define m7_i5  m_m7.m7i5
#define m7_p1  m_m7.m7p1
#define m7_p2  m_m7.m7p2

#define m9_l1  m_m9.m9l1
#define m9_l2  m_m9.m9l2
#define m9_l3  m_m9.m9l3
#define m9_l4  m_m9.m9l4
#define m9_l5  m_m9.m9l5
#define m9_s1  m_m9.m9s1
#define m9_s2  m_m9.m9s2
#define m9_s3  m_m9.m9s3
#define m9_s4  m_m9.m9s4
#define m9_ull1  m_m9.m9ull1
#define m9_ull2  m_m9.m9ull2

#define m10_i1 m_m10.m10i1
#define m10_i2 m_m10.m10i2
#define m10_i3 m_m10.m10i3
#define m10_i4 m_m10.m10i4
#define m10_l1 m_m10.m10l1
#define m10_l2 m_m10.m10l2
#define m10_l3 m_m10.m10l3
#define m10_ull1 m_m10.m10ull1


/*==========================================================================* 
 * Minix run-time system (IPC). 					    *
 *==========================================================================*/ 

/* Datastructure for asynchronous sends */
typedef struct asynmsg
{
	unsigned flags;
	endpoint_t dst;
	int result;
	message msg;
} asynmsg_t;

/* Defines for flags field */
#define AMF_EMPTY	000	/* slot is not inuse */
#define AMF_VALID	001	/* slot contains message */
#define AMF_DONE	002	/* Kernel has processed the message. The
				 * result is stored in 'result'
				 */
#define AMF_NOTIFY	004	/* Send a notification when AMF_DONE is set */
#define AMF_NOREPLY	010	/* Not a reply message for a SENDREC */
#define AMF_NOTIFY_ERR	020	/* Send a notification when AMF_DONE is set and
				 * delivery of the message failed */

int _ipc_send_intr(endpoint_t dest, message *m_ptr);
int _ipc_receive_intr(endpoint_t src, message *m_ptr, int *status_ptr);
int _ipc_sendrec_intr(endpoint_t src_dest, message *m_ptr);
int _ipc_sendnb_intr(endpoint_t dest, message *m_ptr);
int _ipc_notify_intr(endpoint_t dest);
int _ipc_senda_intr(asynmsg_t *table, size_t count);

int _do_kernel_call_intr(message *m_ptr);

int ipc_minix_kerninfo(struct minix_kerninfo **);

/* Hide names to avoid name space pollution. */
#define ipc_notify	_ipc_notify
#define ipc_sendrec	_ipc_sendrec
#define ipc_receive	_ipc_receive
#define ipc_receivenb	_ipc_receivenb
#define ipc_send	_ipc_send
#define ipc_sendnb	_ipc_sendnb
#define ipc_senda	_ipc_senda

#define do_kernel_call	_do_kernel_call

struct minix_ipcvecs {
	int (*send)(endpoint_t dest, message *m_ptr);
	int (*receive)(endpoint_t src, message *m_ptr, int *st);
	int (*sendrec)(endpoint_t src_dest, message *m_ptr);
	int (*sendnb)(endpoint_t dest, message *m_ptr);
	int (*notify)(endpoint_t dest);
	int (*do_kernel_call)(message *m_ptr);
	int (*senda)(asynmsg_t *table, size_t count);
};

/* kernel-set IPC vectors retrieved by a constructor in
 * minix/lib/libc/sys/init.c */
extern struct minix_ipcvecs _minix_ipcvecs;

static inline int _ipc_send(endpoint_t dest, message *m_ptr)
{
	return _minix_ipcvecs.send(dest, m_ptr);
}

static inline int _ipc_receive(endpoint_t src, message *m_ptr, int *st)
{
	return _minix_ipcvecs.receive(src, m_ptr, st);
}

static inline int _ipc_sendrec(endpoint_t src_dest, message *m_ptr)
{
	return _minix_ipcvecs.sendrec(src_dest, m_ptr);
}

static inline int _ipc_sendnb(endpoint_t dest, message *m_ptr)
{
	return _minix_ipcvecs.sendnb(dest, m_ptr);
}

static inline int _ipc_notify(endpoint_t dest)
{
	return _minix_ipcvecs.notify(dest);
}

static inline int _do_kernel_call(message *m_ptr)
{
	return _minix_ipcvecs.do_kernel_call(m_ptr);
}

static inline int _ipc_senda(asynmsg_t *table, size_t count)
{
	return _minix_ipcvecs.senda(table, count);
}

#endif /* _IPC_H */