/lab4/.minix-src/include/minix/ipc.h - LCOM1920-T02G10 - FEUP Project Manager

root / lab4 / .minix-src / include / minix / ipc.h @ 13

History | View | Annotate | Download (57.4 KB)

       #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
       #define CTL_SHORTNAME 8 /* max sysctl(2) name length that fits in message */
       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;
               vir_bytes        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        oldp;
               size_t                oldlen;
               vir_bytes        newp;
               size_t                newlen;
               unsigned int        namelen;
               vir_bytes        namep;
               int                name[CTL_SHORTNAME];
       } mess_lc_mib_sysctl;
       _ASSERT_MSG_SIZE(mess_lc_mib_sysctl);
       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;
               int nblock;
               uint8_t padding[48];
       } 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 {
               size_t labellen;
               size_t buflen;
               vir_bytes label;
               vir_bytes buf;
               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 {
               int fd;
               int backlog;
               u8_t padding[48];
       } mess_lc_vfs_listen;
       _ASSERT_MSG_SIZE(mess_lc_vfs_listen);
       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 {
               /*
                * We are in the process of cleaning up this message, by moving the
                * flags value from the third integer into the first.  Once enough time
                * has passed, we can get rid of the second and third integer fields.
                */
               int flags;
               int _unused;
               int oflags;
               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;
               size_t cum_io;                /* reserved/internal, set to 0 */
               uint8_t padding[40];
       } 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 {
               int fd;
               vir_bytes buf;                /* void * */
               size_t len;
               int flags;
               vir_bytes addr;                /* struct sockaddr * */
               unsigned int addr_len;        /* socklen_t */
               uint8_t padding[32];
       } mess_lc_vfs_sendrecv;
       _ASSERT_MSG_SIZE(mess_lc_vfs_sendrecv);
       typedef struct {
               int fd;
               int how;
               uint8_t padding[48];
       } mess_lc_vfs_shutdown;
       _ASSERT_MSG_SIZE(mess_lc_vfs_shutdown);
       typedef struct {
               int fd;
               vir_bytes addr;                /* struct sockaddr * */
               unsigned int addr_len;        /* socklen_t */
               uint8_t padding[44];
       } mess_lc_vfs_sockaddr;
       _ASSERT_MSG_SIZE(mess_lc_vfs_sockaddr);
       typedef struct {
               int domain;
               int type;
               int protocol;
               uint8_t padding[44];
       } mess_lc_vfs_socket;
       _ASSERT_MSG_SIZE(mess_lc_vfs_socket);
       typedef struct {
               int fd;
               vir_bytes msgbuf;        /* struct msghdr * */
               int flags;
               uint8_t padding[44];
       } mess_lc_vfs_sockmsg;
       _ASSERT_MSG_SIZE(mess_lc_vfs_sockmsg);
       typedef struct {
               int fd;
               int level;
               int name;
               vir_bytes buf;                /* void * */
               unsigned int len;        /* socklen_t */
               uint8_t padding[36];
       } mess_lc_vfs_sockopt;
       _ASSERT_MSG_SIZE(mess_lc_vfs_sockopt);
       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 {
               int32_t req_id;
               int32_t sock_id;
               int status;
               unsigned int len;
               uint8_t padding[40];
       } mess_lsockdriver_vfs_accept_reply;
       _ASSERT_MSG_SIZE(mess_lsockdriver_vfs_accept_reply);
       typedef struct {
               int32_t req_id;
               int status;
               unsigned int ctl_len;
               unsigned int addr_len;
               int flags;
               uint8_t padding[36];
       } mess_lsockdriver_vfs_recv_reply;
       _ASSERT_MSG_SIZE(mess_lsockdriver_vfs_recv_reply);
       typedef struct {
               int32_t req_id;
               int status;
               uint8_t padding[48];
       } mess_lsockdriver_vfs_reply;
       _ASSERT_MSG_SIZE(mess_lsockdriver_vfs_reply);
       typedef struct {
               int32_t sock_id;
               int status;
               uint8_t padding[48];
       } mess_lsockdriver_vfs_select_reply;
       _ASSERT_MSG_SIZE(mess_lsockdriver_vfs_select_reply);
       typedef struct {
               int32_t req_id;
               int32_t sock_id;
               int32_t sock_id2;
               uint8_t padding[44];
       } mess_lsockdriver_vfs_socket_reply;
       _ASSERT_MSG_SIZE(mess_lsockdriver_vfs_socket_reply);
       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;
               int niced;
               uint8_t padding[36];
       } 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 {
               void                *vec_addr;
               int                vec_size;
               uint8_t padding[48];
       } mess_lsys_kern_vsafecopy;
       _ASSERT_MSG_SIZE(mess_lsys_kern_vsafecopy);
       typedef struct {
               uint32_t        root_id;
               uint32_t        flags;
               unsigned int        csize;
               unsigned int        clen;
               unsigned int        miblen;
               int                mib[CTL_SHORTNAME];
               uint8_t                padding[4];
       } mess_lsys_mib_register;
       _ASSERT_MSG_SIZE(mess_lsys_mib_register);
       typedef struct {
               uint32_t        req_id;
               ssize_t                status;
               uint8_t                padding[48];
       } mess_lsys_mib_reply;
       _ASSERT_MSG_SIZE(mess_lsys_mib_reply);
       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;
               vir_bytes groups;
               int ngroups;
               uint8_t padding[44];
       } 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 {
               unsigned int mask;
               uint8_t padding[52];
       } mess_lsys_pm_proceventmask;
       _ASSERT_MSG_SIZE(mess_lsys_pm_proceventmask);
       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;
               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;
               int ndomains;
               int domains[NR_DOMAIN];
               uint8_t padding[8];
       } mess_lsys_vfs_mapdriver;
       _ASSERT_MSG_SIZE(mess_lsys_vfs_mapdriver);
       typedef struct {
               endpoint_t endpt;
               cp_grant_id_t grant;
               size_t count;
               int what;
               uint8_t padding[40];
       } mess_lsys_vfs_socketpath;
       _ASSERT_MSG_SIZE(mess_lsys_vfs_socketpath);
       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        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 {
               size_t                oldlen;
               uint8_t                padding[52];
       } mess_mib_lc_sysctl;
       _ASSERT_MSG_SIZE(mess_mib_lc_sysctl);
       typedef struct {
               uint32_t        req_id;
               uint32_t        root_id;
               cp_grant_id_t        name_grant;
               unsigned int        name_len;
               cp_grant_id_t        oldp_grant;
               size_t                oldp_len;
               cp_grant_id_t        newp_grant;
               size_t                newp_len;
               endpoint_t        user_endpt;
               uint32_t        flags;
               uint32_t        root_ver;
               uint32_t        tree_ver;
               uint8_t                padding[8];
       } mess_mib_lsys_call;
       _ASSERT_MSG_SIZE(mess_mib_lsys_call);
       typedef struct {
               uint32_t        req_id;
               uint32_t        root_id;
               cp_grant_id_t        name_grant;
               size_t                name_size;
               cp_grant_id_t        desc_grant;
               size_t                desc_size;
               uint8_t                padding[32];
       } mess_mib_lsys_info;
       _ASSERT_MSG_SIZE(mess_mib_lsys_info);
       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 {
               uint32_t id;
               uint8_t padding[52];
       } mess_ndev_netdriver_init;
       _ASSERT_MSG_SIZE(mess_ndev_netdriver_init);
       typedef struct {
               uint32_t id;
               uint32_t set;
               uint32_t mode;
               cp_grant_id_t mcast_grant;
               unsigned int mcast_count;
               uint32_t caps;
               uint32_t flags;
               uint32_t media;
               uint8_t hwaddr[NDEV_HWADDR_MAX];
               uint8_t padding[18];
       } mess_ndev_netdriver_conf;
       _ASSERT_MSG_SIZE(mess_ndev_netdriver_conf);
       typedef struct {
               uint32_t id;
               uint32_t count;
               cp_grant_id_t grant[NDEV_IOV_MAX];
               uint16_t len[NDEV_IOV_MAX];
       } mess_ndev_netdriver_transfer;
       _ASSERT_MSG_SIZE(mess_ndev_netdriver_transfer);
       typedef struct {
               uint32_t id;
               uint8_t padding[52];
       } mess_ndev_netdriver_status_reply;
       _ASSERT_MSG_SIZE(mess_ndev_netdriver_status_reply);
       typedef struct {
               uint32_t id;
               uint32_t link;
               uint32_t media;
               uint32_t caps;
               char name[NDEV_NAME_MAX];
               uint8_t hwaddr[NDEV_HWADDR_MAX];
               uint8_t hwaddr_len;
               uint8_t max_send;
               uint8_t max_recv;
               uint8_t padding[15];
       } mess_netdriver_ndev_init_reply;
       _ASSERT_MSG_SIZE(mess_netdriver_ndev_init_reply);
       typedef struct {
               uint32_t id;
               int32_t result;
               uint8_t padding[48];
       } mess_netdriver_ndev_reply;
       _ASSERT_MSG_SIZE(mess_netdriver_ndev_reply);
       typedef struct {
               uint32_t id;
               uint32_t link;
               uint32_t media;
               uint32_t oerror;
               uint32_t coll;
               uint32_t ierror;
               uint32_t iqdrop;
               uint8_t padding[28];
       } mess_netdriver_ndev_status;
       _ASSERT_MSG_SIZE(mess_netdriver_ndev_status);
       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;
               uid_t euid;
               gid_t gid;
               gid_t egid;
               int ngroups;
               uint8_t padding[36];
       } 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 {
               endpoint_t endpt;
               unsigned int event;
               uint8_t padding[48];
       } mess_pm_lsys_proc_event;
       _ASSERT_MSG_SIZE(mess_pm_lsys_proc_event);
       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 {
               int fd0;
               int fd1;
               uint8_t padding[48];
       } mess_vfs_lc_fdpair;
       _ASSERT_MSG_SIZE(mess_vfs_lc_fdpair);
       typedef struct {
               off_t offset;
               uint8_t padding[48];
       } mess_vfs_lc_lseek;
       _ASSERT_MSG_SIZE(mess_vfs_lc_lseek);
       typedef struct {
               unsigned int len;        /* socklen_t */
               uint8_t padding[52];
       } mess_vfs_lc_socklen;
       _ASSERT_MSG_SIZE(mess_vfs_lc_socklen);
       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 {
               int32_t req_id;
               int32_t sock_id;
               cp_grant_id_t grant;
               unsigned int len;
               endpoint_t user_endpt;
               int sflags;
               uint8_t padding[32];
       } mess_vfs_lsockdriver_addr;
       _ASSERT_MSG_SIZE(mess_vfs_lsockdriver_addr);
       typedef struct {
               int32_t req_id;
               int32_t sock_id;
               int level;
               int name;
               cp_grant_id_t grant;
               unsigned int len;
               uint8_t padding[32];
       } mess_vfs_lsockdriver_getset;
       _ASSERT_MSG_SIZE(mess_vfs_lsockdriver_getset);
       typedef struct {
               int32_t req_id;
               int32_t sock_id;
               unsigned long request;
               cp_grant_id_t grant;
               endpoint_t user_endpt;
               int sflags;
               uint8_t padding[32];
       } mess_vfs_lsockdriver_ioctl;
       _ASSERT_MSG_SIZE(mess_vfs_lsockdriver_ioctl);
       typedef struct {
               int32_t sock_id;
               int ops;
               uint8_t padding[48];
       } mess_vfs_lsockdriver_select;
       _ASSERT_MSG_SIZE(mess_vfs_lsockdriver_select);
       typedef struct {
               int32_t req_id;
               int32_t sock_id;
               cp_grant_id_t data_grant;
               size_t data_len;
               cp_grant_id_t ctl_grant;
               unsigned int ctl_len;
               cp_grant_id_t addr_grant;
               unsigned int addr_len;
               endpoint_t user_endpt;
               int flags;
               uint8_t padding[16];
       } mess_vfs_lsockdriver_sendrecv;
       _ASSERT_MSG_SIZE(mess_vfs_lsockdriver_sendrecv);
       typedef struct {
               int32_t req_id;
               int32_t sock_id;
               int param;
               uint8_t padding[44];
       } mess_vfs_lsockdriver_simple;
       _ASSERT_MSG_SIZE(mess_vfs_lsockdriver_simple);
       typedef struct {
               int32_t req_id;
               int domain;
               int type;
               int protocol;
               endpoint_t user_endpt;
               uint8_t padding[36];
       } mess_vfs_lsockdriver_socket;
       _ASSERT_MSG_SIZE(mess_vfs_lsockdriver_socket);
       typedef struct {
               cp_grant_id_t grant;
               size_t size;
               uint8_t padding[48];
       } mess_vfs_lsys_gcov;
       _ASSERT_MSG_SIZE(mess_vfs_lsys_gcov);
       typedef struct {
               dev_t device;
               ino_t inode;
               uint8_t padding[40];
       } mess_vfs_lsys_socketpath;
       _ASSERT_MSG_SIZE(mess_vfs_lsys_socketpath);
       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_mib_sysctl        m_lc_mib_sysctl;
                       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_listen        m_lc_vfs_listen;
                       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_sendrecv        m_lc_vfs_sendrecv;
                       mess_lc_vfs_shutdown        m_lc_vfs_shutdown;
                       mess_lc_vfs_sockaddr        m_lc_vfs_sockaddr;
                       mess_lc_vfs_socket        m_lc_vfs_socket;
                       mess_lc_vfs_sockmsg        m_lc_vfs_sockmsg;
                       mess_lc_vfs_sockopt        m_lc_vfs_sockopt;
                       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_lsockdriver_vfs_accept_reply
                           m_lsockdriver_vfs_accept_reply;
                       mess_lsockdriver_vfs_recv_reply
                           m_lsockdriver_vfs_recv_reply;
                       mess_lsockdriver_vfs_reply        m_lsockdriver_vfs_reply;
                       mess_lsockdriver_vfs_select_reply
                           m_lsockdriver_vfs_select_reply;
                       mess_lsockdriver_vfs_socket_reply
                           m_lsockdriver_vfs_socket_reply;
                       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_mib_register        m_lsys_mib_register;
                       mess_lsys_mib_reply        m_lsys_mib_reply;
                       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_proceventmask m_lsys_pm_proceventmask;
                       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_copyfd        m_lsys_vfs_copyfd;
                       mess_lsys_vfs_mapdriver        m_lsys_vfs_mapdriver;
                       mess_lsys_vfs_socketpath m_lsys_vfs_socketpath;
                       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_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_mib_lc_sysctl        m_mib_lc_sysctl;
                       mess_mib_lsys_call        m_mib_lsys_call;
                       mess_mib_lsys_info        m_mib_lsys_info;
                       mess_mmap                m_mmap;
                       mess_ndev_netdriver_init m_ndev_netdriver_init;
                       mess_ndev_netdriver_conf m_ndev_netdriver_conf;
                       mess_ndev_netdriver_transfer m_ndev_netdriver_transfer;
                       mess_ndev_netdriver_status_reply m_ndev_netdriver_status_reply;
                       mess_netdriver_ndev_init_reply m_netdriver_ndev_init_reply;
                       mess_netdriver_ndev_reply m_netdriver_ndev_reply;
                       mess_netdriver_ndev_status m_netdriver_ndev_status;
                       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_proc_event        m_pm_lsys_proc_event;
                       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_fdpair        m_vfs_lc_fdpair;
                       mess_vfs_lc_lseek        m_vfs_lc_lseek;
                       mess_vfs_lc_socklen        m_vfs_lc_socklen;
                       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_lsockdriver_addr        m_vfs_lsockdriver_addr;
                       mess_vfs_lsockdriver_getset        m_vfs_lsockdriver_getset;
                       mess_vfs_lsockdriver_ioctl        m_vfs_lsockdriver_ioctl;
                       mess_vfs_lsockdriver_select        m_vfs_lsockdriver_select;
                       mess_vfs_lsockdriver_sendrecv        m_vfs_lsockdriver_sendrecv;
                       mess_vfs_lsockdriver_simple        m_vfs_lsockdriver_simple;
                       mess_vfs_lsockdriver_socket        m_vfs_lsockdriver_socket;
                       mess_vfs_lsys_gcov        m_vfs_lsys_gcov;
                       mess_vfs_lsys_socketpath        m_vfs_lsys_socketpath;
                       mess_vfs_utimens        m_vfs_utimens;
                       mess_vm_vfs_mmap        m_vm_vfs_mmap;
                       mess_vmmcp                m_vmmcp;
                       mess_vmmcp_reply        m_vmmcp_reply;
                       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 */

Project

General

Profile

LCOM1920-T02G10

root / lab4 / .minix-src / include / minix / ipc.h @ 13